aboutsummaryrefslogtreecommitdiffstats
path: root/erts/doc/src/erl_driver.xml
blob: f2aea77dee9f0d16d91203c450dd817241c0f3e1 (plain) (blame)
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
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE cref SYSTEM "cref.dtd">

<cref>
  <header>
    <copyright>
      <year>2001</year><year>2018</year>
      <holder>Ericsson AB. All Rights Reserved.</holder>
    </copyright>
    <legalnotice>
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
 
          http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.

    </legalnotice>
    <title>erl_driver</title>
    <prepared>Jakob Cederlund</prepared>
    <responsible>Jakob Cederlund</responsible>
    <docno>1</docno>
    <approved></approved>
    <checked></checked>
    <date>2000-11-27</date>
    <rev>PA1</rev>
    <file>erl_driver.xml</file>
  </header>
  <lib>erl_driver</lib>
  <libsummary>API functions for an Erlang driver.</libsummary>
  <description>
    <p>An Erlang driver is a library containing a set of native driver
      callback functions that the Erlang Virtual Machine calls when certain
      events occur. There can be multiple instances of a driver, each
      instance is associated with an Erlang port.</p>

    <marker id="WARNING"/>
    <warning>
      <p><em>Use this functionality with extreme care.</em></p>
      <p>A driver callback is executed as a direct extension of the
        native code of the VM. Execution is not made in a safe environment.
        The VM <em>cannot</em> provide the same services as provided when
        executing Erlang code, such as pre-emptive scheduling or memory
        protection. If the driver callback function does not behave well,
        the whole VM will misbehave.</p>
      <list type="bulleted">
        <item>
          <p>A driver callback that crash will crash the whole VM.</p>
        </item>
        <item>
          <p>An erroneously implemented driver callback can cause a VM
            internal state inconsistency, which can cause a crash of the VM,
            or miscellaneous misbehaviors of the VM at any point after the
            call to the driver callback.</p>
        </item>
        <item>
          <p>A driver callback doing
            <seealso marker="#lengthy_work">lengthy work</seealso> before
            returning degrades responsiveness of the VM and can cause
            miscellaneous strange behaviors. Such strange behaviors
            include, but are not limited to, extreme memory usage and bad
            load balancing between schedulers. Strange behaviors that can
            occur because of lengthy work can also vary between Erlang/OTP
            releases.</p>
        </item>
      </list>
    </warning>

    <p>As from ERTS 5.5.3 the driver interface has been extended
      (see <seealso marker="driver_entry#extended_marker">
      <c>extended marker</c></seealso>). The extended interface introduces
      <seealso marker="#version_management">version management</seealso>,
      the possibility to pass capability flags (see
      <seealso marker="driver_entry#driver_flags">
      <c>driver_flags</c></seealso>) to the runtime system at driver
      initialization, and some new driver API functions.</p>

    <note>
      <p>As from ERTS 5.9 old drivers must be recompiled
        and use the extended interface. They must also be adjusted to the
        <seealso marker="#rewrites_for_64_bits">
        64-bit capable driver interface</seealso>.</p>
    </note>

    <p>The driver calls back to the emulator, using the API
      functions declared in <c>erl_driver.h</c>. They are used for
      outputting data from the driver, using timers, and so on.</p>

    <p>Each driver instance is associated with a port. Every port
      has a port owner process. Communication with the port is normally
      done through the port owner process. Most of the functions take
      the <c>port</c> handle as an argument. This identifies the driver
      instance. Notice that this port handle must be stored by the driver,
      it is not given when the driver is called from the emulator (see
      <seealso marker="driver_entry#emulator">
      <c>driver_entry</c></seealso>).</p>

    <p>Some of the functions take a parameter of type
      <c>ErlDrvBinary</c>, a driver binary. It is to be both
      allocated and freed by the caller. Using a binary directly avoids
      one extra copying of data.</p>

    <p>Many of the output functions have a "header buffer", with
      <c>hbuf</c> and <c>hlen</c> parameters. This buffer is sent as a
      list before the binary (or list, depending on port mode) that is
      sent. This is convenient when matching on messages received from
      the port. (Although in the latest Erlang versions there is
      the binary syntax, which enables you to match on the beginning of
      a binary.)</p>
    <p><marker id="smp_support"></marker>In the runtime system with
      SMP support, drivers are locked either on driver level
      or port level (driver instance level). By default
      driver level locking will be used, that is, only one emulator thread
      will execute code in the driver at a time. If port level locking
      is used, multiple emulator threads can execute code in the driver
      at the same time. Only one thread at a time will call
      driver callbacks corresponding to the same port, though.
      To enable port level locking, set the <c>ERL_DRV_FLAG_USE_PORT_LOCKING</c>
      <seealso marker="driver_entry#driver_flags">driver flag</seealso> in
      the <seealso marker="driver_entry"><c>driver_entry</c></seealso>
      used by the driver. When port level locking is used,
      the driver writer is responsible for synchronizing all accesses
      to data shared by the ports (driver instances).</p>

    <p>Most drivers written before the runtime system with SMP
      support existed can run in the runtime system
      with SMP support, without being rewritten, if driver
      level locking is used.</p>

    <note>
      <p>It is assumed that drivers do not access other drivers. If
        drivers access each other, they must provide their own
        mechanism for thread-safe synchronization. Such "inter-driver
        communication" is strongly discouraged.</p>
    </note>

    <p>Previously, in the runtime system without SMP support,
      specific driver callbacks were always called from the same
      thread. This is <em>not</em> the case in the runtime system
      with SMP support. Regardless of locking scheme used, calls
      to driver callbacks can be made from different threads. For example,
      two consecutive calls to exactly the same callback for exactly
      the same port can be made from two different threads. This
      is for <em>most</em> drivers not a problem, but it can be.
      Drivers that depend on all callbacks that are called in the
      same thread, <em>must</em> be rewritten before they are used
      in the runtime system with SMP support.</p>

    <note>
      <p>Regardless of locking scheme used, calls to driver
        callbacks can be made from different threads.</p>
    </note>

    <p>Most functions in this API are <em>not</em> thread-safe, that is,
      they <em>cannot</em> be called from arbitrary threads. Functions
      that are not documented as thread-safe can only be called from
      driver callbacks or function calls descending from a driver
      callback call. Notice that driver callbacks can be called from
      different threads. This, however, is not a problem for any
      function in this API, as the emulator has control over
      these threads.</p>

    <warning>
      <p>Functions not explicitly documented as thread-safe are
        <em>not</em> thread safe. Also notice that some functions
        are <em>only</em> thread-safe when used in a runtime
        system with SMP support.</p>
      <p>A function not explicitly documented as thread-safe can, at
        some point in time, have a thread-safe implementation in the
        runtime system. Such an implementation can however change to
        a thread <em>unsafe</em> implementation at any time <em>without
        any notice</em>.</p>
      <p><em>Only use functions explicitly documented as thread-safe
        from arbitrary threads.</em></p>
    </warning>

    <p><marker id="lengthy_work"/>
      As mentioned in the <seealso marker="#WARNING">warning</seealso> text at
      the beginning of this section, it is of vital importance that a driver
      callback returns relatively fast. It is difficult to give an exact
      maximum amount of time that a driver callback is allowed to work, but
      usually a well-behaving driver callback is to return within 1 millisecond.
      This can be achieved using different approaches.
      If you have full control over the code to execute in the driver
      callback, the best approach is to divide the work into multiple chunks of
      work, and trigger multiple calls to the
      <seealso marker="driver_entry#timeout">time-out callback</seealso> using
      zero time-outs. Function <seealso marker="#erl_drv_consume_timeslice">
      <c>erl_drv_consume_timeslice</c></seealso> can be useful to
      determine when to trigger such time-out callback calls. However, sometimes
      it cannot be implemented this way, for example when calling
      third-party libraries. In this case, you typically want to dispatch the
      work to another thread. Information about thread primitives is provided
      below.</p>
  </description>

  <section>
    <title>Functionality</title>
    <p>All functions that a driver needs to do with Erlang are
      performed through driver API functions. Functions exist
      for the following functionality:</p>

    <taglist>
      <tag>Timer functions</tag>
      <item>
        <p>Control the timer that a driver can use. The timer has the
          emulator call the <seealso marker="driver_entry#timeout">
          <c>timeout</c></seealso> entry function after a specified time.
          Only one timer is available for each driver instance.</p>
      </item>
      <tag>Queue handling</tag>
      <item>
        <p>Every driver instance has an associated queue. This queue is a
          <c>SysIOVec</c>, which works as a buffer. It is mostly used for
          the driver to buffer data that is to be written to a device,
          it is a byte stream. If the port owner process closes the
          driver, and the queue is not empty, the driver is not
          closed. This enables the driver to flush its buffers before
          closing.</p>
        <p>The queue can be manipulated from any threads if
          a port data lock is used. For more information, see
          <seealso marker="#ErlDrvPDL"><c>ErlDrvPDL</c></seealso>.</p>
      </item>
      <tag>Output functions</tag>
      <item>
        <p>With these functions, the driver sends data back to the emulator.
          The data is received as messages by the port owner process, see
          <seealso marker="erlang:open_port/2">
          <c>erlang:open_port/2</c></seealso>. The vector function and the
          function taking a driver binary are faster, as they avoid
          copying the data buffer. There is also a fast way of sending
          terms from the driver, without going through the binary term
          format.</p></item>
      <tag>Failure</tag>
      <item>
        <p>The driver can exit and signal errors up to Erlang. This is
          only for severe errors, when the driver cannot possibly keep
          open.</p>
      </item>
      <tag>Asynchronous calls</tag>
      <item>
        <p>Erlang/OTP R7B and later versions have provision for
          asynchronous function calls, using a thread pool provided by
          Erlang. There is also a select call, which can be used for
          asynchronous drivers.</p>
      </item>
      <tag><marker id="multi_threading"/>Multi-threading</tag>
      <item>
        <p>A POSIX thread like API for multi-threading is provided. The
          Erlang driver thread API only provides a subset of the functionality
          provided by the POSIX thread API. The subset provided is
          more or less the basic functionality needed for multi-threaded
          programming:</p>
        <list>
          <item><seealso marker="#ErlDrvTid">Threads</seealso></item>
          <item><seealso marker="#ErlDrvMutex">Mutexes</seealso></item>
          <item><seealso marker="#ErlDrvCond">
            Condition variables</seealso></item>
          <item><seealso marker="#ErlDrvRWLock">
            Read/write locks</seealso></item>
          <item><seealso marker="#ErlDrvTSDKey">
           Thread-specific data</seealso></item>
        </list>
        <p>The Erlang driver thread API can be used in conjunction with
          the POSIX thread API on UN-ices and with the Windows native thread
          API on Windows. The Erlang driver thread API has the advantage of
          being portable, but there can exist situations where you want to
          use functionality from the POSIX thread API or the Windows
          native thread API.</p>
        <p>The Erlang driver thread API only returns error codes when it is
          reasonable to recover from an error condition. If it is not reasonable
          to recover from an error condition, the whole runtime system is
          terminated. For example, if a create mutex operation fails, an error
          code is returned, but if a lock operation on a mutex fails, the
          whole runtime system is terminated.</p>
        <p>Notice that there is no "condition variable wait with time-out" in
          the Erlang driver thread API. This because of issues with
          <c>pthread_cond_timedwait</c>. When the system clock suddenly
          is changed, it is not always guaranteed that you will wake up from
          the call as expected. An Erlang runtime system must be able to
          cope with sudden changes of the system clock. Therefore, we have
          omitted it from the Erlang driver thread API. In the Erlang driver
          case, time-outs can and are to be handled with the timer functionality
          of the Erlang driver API.</p>
        <p>In order for the Erlang driver thread API to function, thread
          support must be enabled in the runtime system. An Erlang driver
          can check if thread support is enabled by use of
          <seealso marker="#driver_system_info">
          <c>driver_system_info</c></seealso>.
          Notice that some functions in the Erlang driver API are thread-safe
          only when the runtime system has SMP support, also this
          information can be retrieved through
          <seealso marker="#driver_system_info">
          <c>driver_system_info</c></seealso>.
          Also notice that many functions in the Erlang driver API are
          <em>not</em> thread-safe, regardless of whether SMP support is
          enabled or not. If a function is not documented as thread-safe, it
          is <em>not</em> thread-safe.</p>
        <note>
          <p>When executing in an emulator thread, it is
            <em>very important</em> that you unlock <em>all</em> locks you
            have locked before letting the thread out of your control;
            otherwise you are <em>very likely</em> to deadlock the whole
            emulator.</p>
          <p>If you need to use thread-specific data in an emulator
            thread, only have the thread-specific data set while the thread is
            under your control, and clear the thread-specific data before
            you let the thread out of your control.</p>
        </note>
        <p>In the future, debug functionality will probably be
          integrated with the Erlang driver thread API. All functions
          that create entities take a <c>name</c> argument. Currently
          the <c>name</c> argument is unused, but it will be used when
          the debug functionality is implemented. If you name all
          entities created well, the debug functionality will be able
          to give you better error reports.</p>
      </item>
      <tag>Adding/removing drivers</tag>
      <item>
        <p>A driver can add and later remove drivers.</p>
      </item>
      <tag>Monitoring processes</tag>
      <item>
        <p>A driver can monitor a process that does not own a port.</p>
      </item>
      <tag><marker id="version_management"/>Version management</tag>
      <item>
        <p>Version management is enabled for drivers that have set the
          <seealso marker="driver_entry#extended_marker">
          <c>extended_marker</c></seealso> field of their
          <seealso marker="driver_entry"><c>driver_entry</c></seealso>
          to <c>ERL_DRV_EXTENDED_MARKER</c>. <c>erl_driver.h</c> defines:</p>
        <list type="bulleted">
          <item>
            <p><c>ERL_DRV_EXTENDED_MARKER</c></p>
          </item>
          <item>
            <p><c>ERL_DRV_EXTENDED_MAJOR_VERSION</c>, which is incremented when
              driver incompatible changes are made to the Erlang runtime
              system. Normally it suffices to recompile drivers when
              <c>ERL_DRV_EXTENDED_MAJOR_VERSION</c> has changed, but it
              can, under rare circumstances, mean that drivers must
              be slightly modified. If so, this will of course be
              documented.</p>
          </item>
          <item>
            <p><c>ERL_DRV_EXTENDED_MINOR_VERSION</c>, which is incremented when
              new features are added. The runtime system uses the minor version
              of the driver to determine what features to use.</p>
          </item>
        </list>
        <p>The runtime system normally refuses to load a driver if the major
          versions differ, or if the major versions are equal and the
          minor version used by the driver is greater than the one used
          by the runtime system. Old drivers with lower major versions
          are however allowed after a bump of the major version during
          a transition period of two major releases. Such old drivers can,
          however, fail if deprecated features are used.</p>
        <p>The emulator refuses to load a driver that does not use
          the extended driver interface, to allow for 64-bit capable drivers,
          as incompatible type changes for the callbacks
          <seealso marker="driver_entry#output"><c>output</c></seealso>,
          <seealso marker="driver_entry#control"><c>control</c></seealso>, and
          <seealso marker="driver_entry#call"><c>call</c></seealso>
          were introduced in Erlang/OTP R15B. A driver written
          with the old types would compile with warnings and when
          called return garbage sizes to the emulator, causing it
          to read random memory and create huge incorrect result blobs.</p>
        <p>Therefore it is not enough to only recompile drivers written with
          version management for pre R15B types; the types must be changed
          in the driver suggesting other rewrites, especially regarding size
          variables. <em>Investigate all warnings when recompiling.</em></p>
        <p>Also, the API driver functions <c>driver_output*</c> and
          <c>driver_vec_to_buf</c>, <c>driver_alloc/realloc*</c>, and the
          <c>driver_*</c> queue functions were changed to have
          larger length arguments and return values. This is a
          lesser problem, as code that passes smaller types
          gets them auto-converted in the calls, and as long as
          the driver does not handle sizes that overflow an <c>int</c>,
          all will work as before.</p>
      </item>
      <tag><marker id="time_measurement"/>Time measurement</tag>
      <item>
        <p>Support for time measurement in drivers:</p>
        <list type="bulleted">
          <item><seealso marker="#ErlDrvTime">
            <c>ErlDrvTime</c></seealso></item>
          <item><seealso marker="#ErlDrvTimeUnit">
            <c>ErlDrvTimeUnit</c></seealso></item>
          <item><seealso marker="#erl_drv_monotonic_time">
            <c>erl_drv_monotonic_time</c></seealso></item>
          <item><seealso marker="#erl_drv_time_offset">
            <c>erl_drv_time_offset</c></seealso></item>
          <item><seealso marker="#erl_drv_convert_time_unit">
            <c>erl_drv_convert_time_unit</c></seealso></item>
        </list>
      </item>
    </taglist>
  </section>

  <section>
    <marker id="rewrites_for_64_bits"/>
    <title>Rewrites for 64-Bit Driver Interface</title>
    <p>ERTS 5.9 introduced two new integer types,
      <seealso marker="#ErlDrvSizeT"><c>ErlDrvSizeT</c></seealso> and
      <seealso marker="#ErlDrvSSizeT"><c>ErlDrvSSizeT</c></seealso>,
      which can hold 64-bit sizes if necessary.</p>

    <p>To not update a driver and only recompile, it probably works
      when building for a 32-bit machine creating a false sense of security.
      Hopefully that will generate many important warnings.
      But when recompiling the same driver later on for a 64-bit machine,
      there <em>will</em> be warnings and almost certainly crashes.
      So it is a <em>bad</em> idea to postpone updating the driver and
      not fixing the warnings.</p>

    <p>When recompiling with <c>gcc</c>, use flag <c>-Wstrict-prototypes</c>
      to get better warnings. Try to find a similar flag if you use
      another compiler.</p>

    <p>The following is a checklist for rewriting a pre ERTS 5.9 driver,
      most important first:</p>

    <taglist>
      <tag>Return types for driver callbacks</tag>
      <item>
	<p>Rewrite driver callback
	  <seealso marker="driver_entry#control"><c>control</c></seealso>
	  to use return type <c>ErlDrvSSizeT</c> instead of <c>int</c>.</p>
	<p>Rewrite driver callback
	  <seealso marker="driver_entry#call"><c>call</c></seealso>
	  to use return type <c>ErlDrvSSizeT</c> instead of <c>int</c>.</p>
	<note>
	  <p>These changes are essential not to crash the emulator
	    or worse cause malfunction.
	    Without them a driver can return garbage in the high 32 bits
	    to the emulator, causing it to build a huge result from random
	    bytes, either crashing on memory allocation or succeeding with
	    a random result from the driver call.</p>
	</note>
      </item>
      <tag>Arguments to driver callbacks</tag>
      <item>
	<p>Driver callback
	  <seealso marker="driver_entry#output"><c>output</c></seealso>
	  now gets <c>ErlDrvSizeT</c> as 3rd argument instead
	  of previously <c>int</c>.</p>
	<p>Driver callback
	  <seealso marker="driver_entry#control"><c>control</c></seealso>
	  now gets <c>ErlDrvSizeT</c> as 4th and 6th arguments instead
	  of previously <c>int</c>.</p>
	<p>Driver callback
	  <seealso marker="driver_entry#call"><c>call</c></seealso>
	  now gets <c>ErlDrvSizeT</c> as 4th and 6th arguments instead
	  of previously <c>int</c>.</p>
	<p>Sane compiler's calling conventions probably make these changes
	  necessary only for a driver to handle data chunks that require
	  64-bit size fields (mostly larger than 2 GB, as that is what
	  an <c>int</c> of 32 bits can hold). But it is possible to think
	  of non-sane calling conventions that would make the driver
	  callbacks mix up the arguments causing malfunction.</p>
	<note>
	  <p>The argument type change is from signed to unsigned. This
	    can cause problems for, for example, loop termination conditions or
	    error conditions if you only change the types all over the place.
          </p>
	</note>
      </item>
      <tag>Larger <c>size</c> field in <c>ErlIOVec</c></tag>
      <item>
	<p>The <c>size</c> field in
	  <seealso marker="#ErlIOVec"><c>ErlIOVec</c></seealso>
	  has been changed to <c>ErlDrvSizeT</c> from <c>int</c>.
	  Check all code that use that field.</p>
	<p>Automatic type-casting probably makes these changes necessary only
	  for a driver that encounters sizes &gt; 32 bits.</p>
	<note>
	  <p>The <c>size</c> field changed from signed to unsigned. This
	    can cause problems for, for example, loop termination conditions or
	    error conditions if you only change the types all over the place.
          </p>
	</note>
      </item>
      <tag>Arguments and return values in the driver API</tag>
      <item>
	<p>Many driver API functions have changed argument type
	  and/or return value to <c>ErlDrvSizeT</c> from mostly <c>int</c>.
	  Automatic type-casting probably makes these changes necessary only
	  for a driver that encounters sizes &gt; 32 bits.</p>
	<taglist>
	  <tag><seealso marker="#driver_output">
            <c>driver_output</c></seealso></tag>
	  <item>3rd argument</item>
	  <tag><seealso marker="#driver_output2">
            <c>driver_output2</c></seealso></tag>
	  <item>3rd and 5th arguments</item>
	  <tag><seealso marker="#driver_output_binary">
            <c>driver_output_binary</c></seealso></tag>
	  <item>3rd, 5th, and 6th arguments</item>
	  <tag><seealso marker="#driver_outputv">
            <c>driver_outputv</c></seealso></tag>
	  <item>3rd and 5th arguments</item>
	  <tag><seealso marker="#driver_vec_to_buf">
            <c>driver_vec_to_buf</c></seealso></tag>
	  <item>3rd argument and return value</item>
	  <tag><seealso marker="#driver_alloc">
            <c>driver_alloc</c></seealso></tag>
	  <item>1st argument</item>
	  <tag><seealso marker="#driver_realloc">
            <c>driver_realloc</c></seealso></tag>
	  <item>2nd argument</item>
	  <tag><seealso marker="#driver_alloc_binary">
            <c>driver_alloc_binary</c></seealso></tag>
	  <item>1st argument</item>
	  <tag><seealso marker="#driver_realloc_binary">
            <c>driver_realloc_binary</c></seealso></tag>
	  <item>2nd argument</item>
	  <tag><seealso marker="#driver_enq">
            <c>driver_enq</c></seealso></tag>
	  <item>3rd argument</item>
	  <tag><seealso marker="#driver_pushq">
            <c>driver_pushq</c></seealso></tag>
	  <item>3rd argument</item>
	  <tag><seealso marker="#driver_deq">
            <c>driver_deq</c></seealso></tag>
	  <item>2nd argument and return value</item>
	  <tag><seealso marker="#driver_sizeq">
            <c>driver_sizeq</c></seealso></tag>
	  <item>Return value</item>
	  <tag><seealso marker="#driver_enq_bin">
            <c>driver_enq_bin</c></seealso></tag>
	  <item>3rd and 4th arguments</item>
	  <tag><seealso marker="#driver_pushq_bin">
            <c>driver_pushq_bin</c></seealso></tag>
	  <item>3rd and 4th arguments</item>
	  <tag><seealso marker="#driver_enqv">
            <c>driver_enqv</c></seealso></tag>
	  <item>3rd argument</item>
	  <tag><seealso marker="#driver_pushqv">
            <c>driver_pushqv</c></seealso></tag>
	  <item>3rd argument</item>
	  <tag><seealso marker="#driver_peekqv">
            <c>driver_peekqv</c></seealso></tag>
	  <item>Return value</item>
	</taglist>
	<note>
	  <p>This is a change from signed to unsigned. This can cause
	    problems for, for example, loop termination conditions and error
	    conditions if you only change the types all over the place.</p>
	</note>
      </item>
    </taglist>
  </section>

  <section>
    <title>Data Types</title>
    <taglist>
      <tag><marker id="ErlDrvSizeT"/><c>ErlDrvSizeT</c></tag>
      <item>
        <p>An unsigned integer type to be used as <c>size_t</c>.</p>
      </item>
      <tag><marker id="ErlDrvSSizeT"/><c>ErlDrvSSizeT</c></tag>
      <item>
        <p>A signed integer type, the size of <c>ErlDrvSizeT</c>.</p>
      </item>
      <tag><marker id="ErlDrvSysInfo"/><c>ErlDrvSysInfo</c></tag>
      <item>
        <code type="none">
typedef struct ErlDrvSysInfo {
   int driver_major_version;
   int driver_minor_version;
   char *erts_version;
   char *otp_release;
   int thread_support;
   int smp_support;
   int async_threads;
   int scheduler_threads;
   int nif_major_version;
   int nif_minor_version;
   int dirty_scheduler_support;
} ErlDrvSysInfo;</code>
        <p>The <c>ErlDrvSysInfo</c> structure is used for storage of
          information about the Erlang runtime system.
          <seealso marker="#driver_system_info">
          <c>driver_system_info</c></seealso>
          writes the system information when passed a reference to
          a <c>ErlDrvSysInfo</c> structure. The fields in the structure
          are as follows:</p>
        <taglist>
          <tag><c>driver_major_version</c></tag>
          <item>
            <p>The value of <seealso marker="#version_management">
              <c>ERL_DRV_EXTENDED_MAJOR_VERSION</c></seealso>
              when the runtime system was compiled. This value is the same
              as the value of <seealso marker="#version_management">
              <c>ERL_DRV_EXTENDED_MAJOR_VERSION</c></seealso>
              used when compiling the driver; otherwise the runtime system
              would have refused to load the driver.</p>
          </item>
          <tag><c>driver_minor_version</c></tag>
          <item>
            <p>The value of <seealso marker="#version_management">
              <c>ERL_DRV_EXTENDED_MINOR_VERSION</c></seealso>
              when the runtime system was compiled. This value can differ
              from the value of <seealso marker="#version_management">
              <c>ERL_DRV_EXTENDED_MINOR_VERSION</c></seealso>
              used when compiling the driver.</p>
          </item>
          <tag><c>erts_version</c></tag>
          <item>
            <p>A string containing the version number of the runtime system
              (the same as returned by
              <seealso marker="erlang#system_info_version">
              <c>erlang:system_info(version)</c></seealso>).</p>
          </item>
          <tag><c>otp_release</c></tag>
          <item>
            <p>A string containing the OTP release number
              (the same as returned by
              <seealso marker="erlang#system_info_otp_release">
              <c>erlang:system_info(otp_release)</c></seealso>).</p>
          </item>
          <tag><c>thread_support</c></tag>
          <item>
            <p>A value <c>!= 0</c> if the runtime system has thread support;
              otherwise <c>0</c>.</p>
          </item>
          <tag><c>smp_support</c></tag>
          <item>
            <p>A value <c>!= 0</c> if the runtime system has SMP support;
              otherwise <c>0</c>.</p>
          </item>
          <tag><c>async_threads</c></tag>
          <item>
            <p>The number of async threads in the async thread pool used by
              <seealso marker="#driver_async"><c>driver_async</c></seealso>
              (the same as returned by
              <seealso marker="erlang#system_info_thread_pool_size">
              <c>erlang:system_info(thread_pool_size)</c></seealso>).</p>
          </item>
          <tag><c>scheduler_threads</c></tag>
          <item>
            <p>The number of scheduler threads used by the runtime system
              (the same as returned by
              <seealso marker="erlang#system_info_schedulers">
              <c>erlang:system_info(schedulers)</c></seealso>).</p>
          </item>
          <tag><c>nif_major_version</c></tag>
          <item>
            <p>The value of <c>ERL_NIF_MAJOR_VERSION</c> when the runtime
              system was compiled.</p>
          </item>
          <tag><c>nif_minor_version</c></tag>
            <item>
              <p>The value of <c>ERL_NIF_MINOR_VERSION</c> when the runtime
                system was compiled.</p>
          </item>
          <tag><c>dirty_scheduler_support</c></tag>
          <item>
            <p>A value <c>!= 0</c> if the runtime system has support for dirty
              scheduler threads; otherwise <c>0</c>.</p>
          </item>
        </taglist>
      </item>
      <tag><marker id="ErlDrvBinary"/><c>ErlDrvBinary</c></tag>
      <item>
        <code type="none">
typedef struct ErlDrvBinary {
   ErlDrvSint orig_size;
   char orig_bytes[];
} ErlDrvBinary;</code>
        <p>The <c>ErlDrvBinary</c> structure is a binary, as sent
          between the emulator and the driver. All binaries are
          reference counted; when <c>driver_binary_free</c> is called,
          the reference count is decremented, when it reaches zero,
          the binary is deallocated. <c>orig_size</c> is the binary size
          and <c>orig_bytes</c> is the buffer.
          <c>ErlDrvBinary</c> has not a fixed size, its size is
          <c>orig_size + 2 * sizeof(int)</c>.</p>
        <note>
          <p>The <c>refc</c> field has been removed. The reference count of
            an <c>ErlDrvBinary</c> is now stored elsewhere. The
            reference count of an <c>ErlDrvBinary</c> can be accessed through
            <seealso marker="#driver_binary_get_refc">
            <c>driver_binary_get_refc</c></seealso>,
            <seealso marker="#driver_binary_inc_refc">
            <c>driver_binary_inc_refc</c></seealso>, and
            <seealso marker="#driver_binary_dec_refc">
            <c>driver_binary_dec_refc</c></seealso>.</p>
        </note>
        <p>Some driver calls, such as <c>driver_enq_binary</c>,
          increment the driver reference count, and others, such as
          <c>driver_deq</c> decrement it.</p>
        <p>Using a driver binary instead of a normal buffer is often
          faster, as the emulator needs not to copy the data,
          only the pointer is used.</p>
        <p>A driver binary allocated in the driver, with
          <c>driver_alloc_binary</c>, is to be freed in the driver
          (unless otherwise stated)
          with <c>driver_free_binary</c>. (Notice that this does not
          necessarily deallocate it, if the driver is still referred
          in the emulator, the ref-count will not go to zero.)</p>
        <p>Driver binaries are used in the <c>driver_output2</c> and
          <c>driver_outputv</c> calls, and in the queue. Also the
          driver callback <seealso marker="driver_entry#outputv">
          <c>outputv</c></seealso> uses driver binaries.</p>
        <p>If the driver for some reason wants to keep a
          driver binary around, for example in a static variable, the
          reference count is to be incremented, and the binary can later
          be freed in the <seealso marker="driver_entry#stop">
          <c>stop</c></seealso> callback, with <c>driver_free_binary</c>.</p>
        <p>Notice that as a driver binary is shared by the driver and
          the emulator. A binary received from the emulator or sent to
          the emulator must not be changed by the driver.</p>
        <p>Since ERTS 5.5 (Erlang/OTP R11B), <c>orig_bytes</c> is
          guaranteed to be properly aligned for storage of an array of
          doubles (usually 8-byte aligned).</p>
      </item>
      <tag><c>ErlDrvData</c></tag>
      <item>
        <p>A handle to driver-specific data,
          passed to the driver callbacks. It is a pointer, and is
          most often type cast to a specific pointer in the driver.</p>
      </item>
      <tag><c>SysIOVec</c></tag>
      <item>
        <p>A system I/O vector, as used by <c>writev</c> on
          Unix and <c>WSASend</c> on Win32. It is used in
          <c>ErlIOVec</c>.</p>
      </item>
      <tag><marker id="ErlIOVec"/><c>ErlIOVec</c></tag>
      <item>
        <code type="none">
typedef struct ErlIOVec {
  int vsize;
  ErlDrvSizeT size;
  SysIOVec* iov;
  ErlDrvBinary** binv;
} ErlIOVec;</code>
        <p>The I/O vector used by the emulator and drivers is a list
          of binaries, with a <c>SysIOVec</c> pointing to the buffers
          of the binaries. It is used in <c>driver_outputv</c> and the
          <seealso marker="driver_entry#outputv"><c>outputv</c></seealso>
          driver callback. Also, the driver queue is an
          <c>ErlIOVec</c>.</p>
      </item>
      <tag><c>ErlDrvMonitor</c></tag>
      <item>
        <p>When a driver creates a monitor for a process, a
          <c>ErlDrvMonitor</c> is filled in. This is an opaque
          data type that can be assigned to, but not compared without
          using the supplied compare function (that is, it behaves like
          a struct).</p>
        <p>The driver writer is to provide the memory for storing the
          monitor when calling <seealso marker="#driver_monitor_process">
          <c>driver_monitor_process</c></seealso>. The
          address of the data is not stored outside of the driver, so
          <c>ErlDrvMonitor</c> can be used as any other data, it
          can be copied, moved in memory, forgotten, and so on.</p>
      </item>
      <tag><marker id="ErlDrvNowData"/><c>ErlDrvNowData</c></tag>
      <item>
        <p>The <c>ErlDrvNowData</c> structure holds a time stamp
          consisting of three values measured from some arbitrary
          point in the past. The three structure members are:</p>
        <taglist>
          <tag><c>megasecs</c></tag>
          <item>The number of whole megaseconds elapsed since the arbitrary
            point in time</item>
          <tag><c>secs</c></tag>
          <item>The number of whole seconds elapsed since the arbitrary
            point in time</item>
          <tag><c>microsecs</c></tag>
          <item>The number of whole microseconds elapsed since the arbitrary
            point in time</item>
        </taglist>
      </item>
      <tag><marker id="ErlDrvPDL"/><c>ErlDrvPDL</c></tag>
      <item>
        <p>If certain port-specific data must be accessed from other
          threads than those calling the driver callbacks, a port data lock
          can be used to synchronize the operations on the data.
          Currently, the only port-specific data that the emulator
          associates with the port data lock is the driver queue.</p>
        <p>Normally a driver instance has no port data lock. If
          the driver instance wants to use a port data lock, it must
          create the port data lock by calling
          <seealso marker="#driver_pdl_create">
          <c>driver_pdl_create</c></seealso>.</p>
        <note>
          <p>Once the port data lock has been created, every
            access to data associated with the port data lock must be done
            while the port data lock is locked. The port data lock is
            locked and unlocked by
            <seealso marker="#driver_pdl_lock">
            <c>driver_pdl_lock</c></seealso>, and
            <seealso marker="#driver_pdl_unlock">
            <c>driver_pdl_unlock</c></seealso>, respectively.</p>
        </note>
        <p>A port data lock is reference counted, and when the reference
          count reaches zero, it is destroyed. The emulator at
          least increments the reference count once when the lock is
          created and decrements it once the port associated with
          the lock terminates. The emulator also increments the
          reference count when an async job is enqueued and decrements
          it when an async job has been invoked.
          Also, the driver is responsible for ensuring that
          the reference count does not reach zero before the last use
          of the lock by the driver has been made. The reference count
          can be read, incremented, and decremented by
          <seealso marker="#driver_pdl_get_refc">
          <c>driver_pdl_get_refc</c></seealso>,
          <seealso marker="#driver_pdl_inc_refc">
          <c>driver_pdl_inc_refc</c></seealso>, and
          <seealso marker="#driver_pdl_dec_refc">
          <c>driver_pdl_dec_refc</c></seealso>, respectively.</p>
      </item>
      <tag><marker id="ErlDrvTid"/><c>ErlDrvTid</c></tag>
      <item>
        <p>Thread identifier.</p>
	<p>See also <seealso marker="#erl_drv_thread_create">
           <c>erl_drv_thread_create</c></seealso>,
	   <seealso marker="#erl_drv_thread_exit">
           <c>erl_drv_thread_exit</c></seealso>,
	   <seealso marker="#erl_drv_thread_join">
           <c>erl_drv_thread_join</c></seealso>,
	   <seealso marker="#erl_drv_thread_self">
           <c>erl_drv_thread_self</c></seealso>, and
	   <seealso marker="#erl_drv_equal_tids">
           <c>erl_drv_equal_tids</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvThreadOpts"/><c>ErlDrvThreadOpts</c></tag>
      <item>
        <code type="none">
int suggested_stack_size;</code>
        <p>Thread options structure passed to
	  <seealso marker="#erl_drv_thread_create">
            <c>erl_drv_thread_create</c></seealso>.
	    The following field exists:</p>
        <taglist>
          <tag><c>suggested_stack_size</c></tag>
          <item>A suggestion, in kilowords, on how large a stack to use.
            A value &lt; 0 means default size.
	  </item>
        </taglist>
	<p>See also <seealso marker="#erl_drv_thread_opts_create">
	  <c>erl_drv_thread_opts_create</c></seealso>,
	  <seealso marker="#erl_drv_thread_opts_destroy">
	  <c>erl_drv_thread_opts_destroy</c></seealso>, and
	  <seealso marker="#erl_drv_thread_create">
	  <c>erl_drv_thread_create</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvMutex"/><c>ErlDrvMutex</c></tag>
      <item>
        <p>Mutual exclusion lock. Used for synchronizing access to shared data.
	   Only one thread at a time can lock a mutex.</p>
	<p>See also <seealso marker="#erl_drv_mutex_create">
          <c>erl_drv_mutex_create</c></seealso>,
	  <seealso marker="#erl_drv_mutex_destroy">
	  <c>erl_drv_mutex_destroy</c></seealso>,
	  <seealso marker="#erl_drv_mutex_lock">
	  <c>erl_drv_mutex_lock</c></seealso>,
	  <seealso marker="#erl_drv_mutex_trylock">
	  <c>erl_drv_mutex_trylock</c></seealso>, and
	  <seealso marker="#erl_drv_mutex_unlock">
	  <c>erl_drv_mutex_unlock</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvCond"/><c>ErlDrvCond</c></tag>
      <item>
        <p>Condition variable. Used when threads must wait for a specific
	  condition to appear before continuing execution. Condition variables
	  must be used with associated mutexes.</p>
	<p>See also <seealso marker="#erl_drv_cond_create">
	  <c>erl_drv_cond_create</c></seealso>,
	  <seealso marker="#erl_drv_cond_destroy">
	  <c>erl_drv_cond_destroy</c></seealso>,
	  <seealso marker="#erl_drv_cond_signal">
	  <c>erl_drv_cond_signal</c></seealso>,
	  <seealso marker="#erl_drv_cond_broadcast">
	  <c>erl_drv_cond_broadcast</c></seealso>, and
	  <seealso marker="#erl_drv_cond_wait">
	  <c>erl_drv_cond_wait</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvRWLock"/><c>ErlDrvRWLock</c></tag>
      <item>
        <p>Read/write lock. Used to allow multiple threads to read shared data
	  while only allowing one thread to write the same data. Multiple
	  threads can read lock an rwlock at the same time, while only
	  one thread can read/write lock an rwlock at a time.</p>
	<p>See also <seealso marker="#erl_drv_rwlock_create">
	  <c>erl_drv_rwlock_create</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_destroy">
	  <c>erl_drv_rwlock_destroy</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_rlock">
	  <c>erl_drv_rwlock_rlock</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_tryrlock">
	  <c>erl_drv_rwlock_tryrlock</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_runlock">
	  <c>erl_drv_rwlock_runlock</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_rwlock">
	  <c>erl_drv_rwlock_rwlock</c></seealso>,
	  <seealso marker="#erl_drv_rwlock_tryrwlock">
	  <c>erl_drv_rwlock_tryrwlock</c></seealso>, and
	  <seealso marker="#erl_drv_rwlock_rwunlock">
	  <c>erl_drv_rwlock_rwunlock</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvTSDKey"/><c>ErlDrvTSDKey</c></tag>
      <item>
        <p>Key that thread-specific data can be associated with.</p>
	<p>See also <seealso marker="#erl_drv_tsd_key_create">
	  <c>erl_drv_tsd_key_create</c></seealso>,
	  <seealso marker="#erl_drv_tsd_key_destroy">
	  <c>erl_drv_tsd_key_destroy</c></seealso>,
	  <seealso marker="#erl_drv_tsd_set">
	  <c>erl_drv_tsd_set</c></seealso>, and
	  <seealso marker="#erl_drv_tsd_get">
	  <c>erl_drv_tsd_get</c></seealso>.</p>
      </item>
      <tag><marker id="ErlDrvTime"/><c>ErlDrvTime</c></tag>
      <item>
        <p>A signed 64-bit integer type for time representation.</p>
      </item>
      <tag><marker id="ErlDrvTimeUnit"/><c>ErlDrvTimeUnit</c></tag>
      <item>
        <p>An enumeration of time units supported by the driver API:</p>
        <taglist>
	  <tag><c>ERL_DRV_SEC</c></tag>
	  <item>Seconds</item>
	  <tag><c>ERL_DRV_MSEC</c></tag>
	  <item>Milliseconds</item>
	  <tag><c>ERL_DRV_USEC</c></tag>
	  <item>Microseconds</item>
	  <tag><c>ERL_DRV_NSEC</c></tag>
	  <item>Nanoseconds</item>
        </taglist>
      </item>
    </taglist>
  </section>

  <funcs>
    <func>
      <name><ret>void</ret><nametext>add_driver_entry(ErlDrvEntry
        *de)</nametext></name>
      <fsummary>Add a driver entry.</fsummary>
      <desc>
        <marker id="add_driver_entry"></marker>
        <p>Adds a driver entry to the list of drivers known by Erlang.
          The <seealso marker="driver_entry#init"><c>init</c></seealso>
          function of parameter <c>de</c> is called.</p>
        <note>
          <p>To use this function for adding drivers residing in
            dynamically loaded code is dangerous. If the driver code
            for the added driver resides in the same dynamically
            loaded module (that is, <c>.so</c> file) as a normal
            dynamically loaded driver (loaded with the <c>erl_ddll</c>
            interface), the caller is to call
            <seealso marker="#driver_lock_driver">
            <c>driver_lock_driver</c></seealso> before
            adding driver entries.</p>
          <p><em>Use of this function is generally deprecated.</em></p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>void *</ret>
        <nametext>driver_alloc(ErlDrvSizeT size)</nametext></name>
      <fsummary>Allocate memory.</fsummary>
      <desc>
        <marker id="driver_alloc"></marker>
        <p>Allocates a memory block of the size specified
          in <c>size</c>, and returns it. This fails only on out of
          memory, in which case <c>NULL</c> is returned. (This is most
          often a wrapper for <c>malloc</c>).</p>
        <p>Memory allocated must be explicitly freed with a corresponding
          call to <seealso marker="#driver_free"><c>driver_free</c></seealso>
          (unless otherwise stated).</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvBinary *</ret>
        <nametext>driver_alloc_binary(ErlDrvSizeT size)</nametext></name>
      <fsummary>Allocate a driver binary.</fsummary>
      <desc>
        <marker id="driver_alloc_binary"></marker>
        <p>Allocates a driver binary with a memory block
          of at least <c>size</c> bytes, and returns a pointer to it,
          or <c>NULL</c> on failure (out of memory). When a driver binary has
          been sent to the emulator, it must not be changed. Every
          allocated binary is to be freed by a corresponding call to
          <seealso marker="#driver_free_binary">
          <c>driver_free_binary</c></seealso> (unless otherwise stated).</p>
        <p>Notice that a driver binary has an internal reference counter.
          This means that calling <c>driver_free_binary</c>, it may not
          actually dispose of it. If it is sent to the emulator, it can
          be referenced there.</p>
        <p>The driver binary has a field, <c>orig_bytes</c>, which
          marks the start of the data in the binary.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>long</ret><nametext>driver_async(ErlDrvPort port, unsigned
        int* key, void (*async_invoke)(void*), void* async_data, void
        (*async_free)(void*))</nametext></name>
      <fsummary>Perform an asynchronous call within a driver.</fsummary>
      <desc>
        <marker id="driver_async"></marker>
        <p>Performs an asynchronous call. The function
          <c>async_invoke</c> is invoked in a thread separate from the
          emulator thread. This enables the driver to perform
          time-consuming, blocking operations without blocking the
          emulator.</p>
        <p>The async thread pool size can be set with command-line argument
          <seealso marker="erl#async_thread_pool_size"><c>+A</c></seealso>
          in <seealso marker="erl"><c>erl(1)</c></seealso>.
          If an async thread pool is unavailable, the call is made
          synchronously in the thread calling <c>driver_async</c>. The
          current number of async threads in the async thread pool can be
          retrieved through <seealso marker="#driver_system_info">
          <c>driver_system_info</c></seealso>.</p>
        <p>If a thread pool is available, a thread is used.
          If argument <c>key</c> is <c>NULL</c>, the threads from the
          pool are used in a round-robin way, each call to
          <c>driver_async</c> uses the next thread in the pool. With
          argument <c>key</c> set, this behavior is changed. The two
          same values of <c>*key</c> always get the same thread.</p>
        <p>To ensure that a driver instance always uses the same
          thread, the following call can be used:</p>
        <code type="none"><![CDATA[
unsigned int myKey = driver_async_port_key(myPort);

r = driver_async(myPort, &myKey, myData, myFunc);    ]]></code>
        <p>It is enough to initialize <c>myKey</c> once for each
          driver instance.</p>
        <p>If a thread is already working, the calls are
          queued up and executed in order. Using the same thread for
          each driver instance ensures that the calls are made in sequence.</p>
        <p>The <c>async_data</c> is the argument to the functions
          <c>async_invoke</c> and <c>async_free</c>. It is typically a
          pointer to a structure containing a pipe or event that
          can be used to signal that the async operation completed.
          The data is to be freed in <c>async_free</c>.</p>
        <p>When the async operation is done,
          <seealso marker="driver_entry#ready_async">
          <c>ready_async</c></seealso> driver
          entry function is called. If <c>ready_async</c> is <c>NULL</c> in
          the driver entry, the <c>async_free</c> function is called
          instead.</p>
        <p>The return value is <c>-1</c> if the <c>driver_async</c> call
          fails.</p>
        <note>
          <p>As from ERTS 5.5.4.3 the default stack size for
            threads in the async-thread pool is 16 kilowords,
            that is, 64 kilobyte on 32-bit architectures.
            This small default size has been chosen because the
            amount of async-threads can be quite large. The
            default stack size is enough for drivers delivered
            with Erlang/OTP, but is possibly not sufficiently large
            for other dynamically linked-in drivers that use the
            <c>driver_async</c> functionality. A suggested stack size
            for threads in the async-thread pool can be configured
            through command-line argument
            <seealso marker="erl#async_thread_stack_size"><c>+a</c></seealso>
            in <seealso marker="erl"><c>erl(1)</c></seealso>.</p>
        </note>
      </desc>
    </func>

    <func>
      <name since="OTP R16B02"><ret>unsigned int</ret><nametext>driver_async_port_key(ErlDrvPort
        port)</nametext></name>
      <fsummary>Calculate an async key from an ErlDrvPort.</fsummary>
      <desc>
        <marker id="driver_async_port_key"></marker>
        <p>Calculates a key for later use in <seealso
          marker="#driver_async"><c>driver_async</c></seealso>. The keys are
          evenly distributed so that a fair mapping between port IDs
          and async thread IDs is achieved.</p>
        <note>
          <p>Before Erlang/OTP R16, the port ID could be used as a key
            with proper casting, but after the rewrite of the port
            subsystem, this is no longer the case. With this function, you
            can achieve the same distribution based on port IDs as before
            Erlang/OTP R16.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>long</ret>
        <nametext>driver_binary_dec_refc(ErlDrvBinary *bin)</nametext></name>
      <fsummary>Decrement the reference count of a driver binary.</fsummary>
      <desc>
        <marker id="driver_binary_dec_refc"></marker>
        <p>Decrements the reference count on <c>bin</c> and returns
          the reference count reached after the decrement.</p>
        <p>This function is thread-safe.</p>
        <note>
          <p>The reference count of driver binary is normally to be decremented
            by calling <seealso marker="#driver_free_binary">
            <c>driver_free_binary</c></seealso>.</p>
          <p><c>driver_binary_dec_refc</c> does <em>not</em> free
            the binary if the reference count reaches zero. <em>Only</em>
            use <c>driver_binary_dec_refc</c> when you are sure
            <em>not</em> to reach a reference count of zero.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>long</ret>
        <nametext>driver_binary_get_refc(ErlDrvBinary *bin)</nametext></name>
      <fsummary>Get the reference count of a driver binary.</fsummary>
      <desc>
        <marker id="driver_binary_get_refc"></marker>
        <p>Returns the current reference count on <c>bin</c>.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>long</ret>
        <nametext>driver_binary_inc_refc(ErlDrvBinary *bin)</nametext></name>
      <fsummary>Increment the reference count of a driver binary.</fsummary>
      <desc>
        <marker id="driver_binary_inc_refc"></marker>
        <p>Increments the reference count on <c>bin</c> and returns
          the reference count reached after the increment.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTermData</ret><nametext>driver_caller(ErlDrvPort
        port)</nametext></name>
      <fsummary>Return the process making the driver call.</fsummary>
      <desc>
        <marker id="driver_caller"></marker>
        <p>Returns the process ID of the process that
          made the current call to the driver. The process ID can be used with
          <seealso marker="#driver_send_term"><c>driver_send_term</c></seealso>
          to send back data to the caller.
          <c>driver_caller</c> only returns valid data
          when currently executing in one of the following driver callbacks:</p>
        <taglist>
          <tag><seealso marker="driver_entry#start">
            <c>start</c></seealso></tag>
          <item>Called from <seealso marker="erlang:open_port/2">
            <c>erlang:open_port/2</c></seealso>.</item>
          <tag><seealso marker="driver_entry#output">
            <c>output</c></seealso></tag>
          <item>Called from <seealso marker="erlang:send/2">
            <c>erlang:send/2</c></seealso> and
            <seealso marker="erlang:port_command/2">
            <c>erlang:port_command/2</c></seealso>.</item>
          <tag><seealso marker="driver_entry#outputv">
            <c>outputv</c></seealso></tag>
          <item>Called from <seealso marker="erlang:send/2">
            <c>erlang:send/2</c></seealso> and
            <seealso marker="erlang:port_command/2">
            <c>erlang:port_command/2</c></seealso>.</item>
          <tag><seealso marker="driver_entry#control">
            <c>control</c></seealso></tag>
          <item>Called from <seealso marker="erlang:port_control/3">
            <c>erlang:port_control/3</c></seealso>.</item>
          <tag><seealso marker="driver_entry#call">
            <c>call</c></seealso></tag>
          <item>Called from <seealso marker="erlang:port_call/3">
            <c>erlang:port_call/3</c></seealso>.</item>
        </taglist>
        <p>Notice that this function is <em>not</em> thread-safe, not
          even when the emulator with SMP support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret>
        <nametext>driver_cancel_timer(ErlDrvPort port)</nametext></name>
      <fsummary>Cancel a previously set timer.</fsummary>
      <desc>
        <marker id="driver_cancel_timer"></marker>
        <p>Cancels a timer set with
          <seealso marker="#driver_set_timer">
          <c>driver_set_timer</c></seealso>.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_compare_monitors(const ErlDrvMonitor
        *monitor1, const ErlDrvMonitor *monitor2)</nametext></name>
      <fsummary>Compare two monitors.</fsummary>
      <desc>
        <marker id="driver_compare_monitors"></marker>
        <p>Compares two <c>ErlDrvMonitor</c>s.
          Can also be used to imply some artificial order on monitors,
          for whatever reason.</p>
        <p>Returns <c>0</c> if <c>monitor1</c> and <c>monitor2</c> are equal,
          &lt; <c>0</c> if <c>monitor1</c> &lt; <c>monitor2</c>, and
          &gt; <c>0</c> if <c>monitor1</c> &gt; <c>monitor2</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTermData</ret><nametext>driver_connected(ErlDrvPort
        port)</nametext></name>
      <fsummary>Return the port owner process.</fsummary>
      <desc>
        <marker id="driver_connected"></marker>
        <p>Returns the port owner process.</p>
        <p>Notice that this function is <em>not</em> thread-safe, not
          even when the emulator with SMP support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvPort</ret><nametext>driver_create_port(ErlDrvPort port,
        ErlDrvTermData owner_pid, char* name,
        ErlDrvData drv_data)</nametext></name>
      <fsummary>Create a new port (driver instance).</fsummary>
      <desc>
        <p>Creates a new port executing the same driver
          code as the port creating the new port.</p>
        <taglist>
          <tag><c>port</c></tag>
          <item>The port handle of the port (driver instance) creating
            the new port.</item>
          <tag><c>owner_pid</c></tag>
          <item>The process ID of the Erlang process to become
            owner of the new port. This process will be linked
            to the new port. You usually want to use
            <c>driver_caller(port)</c> as <c>owner_pid</c>.</item>
          <tag><c>name</c></tag>
          <item>The port name of the new port. You usually want to
            use the same port name as the driver name
            (<seealso marker="driver_entry#driver_name">
            <c>driver_name</c></seealso> field of the
            <seealso marker="driver_entry"><c>driver_entry</c></seealso>).
          </item>
          <tag><c>drv_data</c></tag>
          <item>The driver-defined handle that is passed in later
            calls to driver callbacks. Notice that the
            <seealso marker="driver_entry#start">driver start
            callback</seealso> is not called for this new driver instance.
            The driver-defined handle is normally created in the
            <seealso marker="driver_entry#start">driver start callback</seealso>
            when a port is created through
            <seealso marker="erlang#open_port/2">
            <c>erlang:open_port/2</c></seealso>.
          </item>
        </taglist>
        <p>The caller of <c>driver_create_port</c> is allowed to
          manipulate the newly created port when <c>driver_create_port</c>
          has returned. When
          <seealso marker="#smp_support">port level locking</seealso>
          is used, the creating port is only allowed to
          manipulate the newly created port until the current driver
          callback, which was called by the emulator, returns.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_demonitor_process(ErlDrvPort port,
        const ErlDrvMonitor *monitor)</nametext></name>
      <fsummary>Stop monitoring a process from a driver.</fsummary>
      <desc>
        <marker id="driver_demonitor_process"></marker>
        <p>Cancels a monitor created earlier.</p>
        <p>Returns <c>0</c> if a monitor was removed and &gt; 0 if the monitor
          no longer exists.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvSizeT</ret><nametext>driver_deq(ErlDrvPort port,
        ErlDrvSizeT size)</nametext></name>
      <fsummary>Dequeue data from the head of the driver queue.</fsummary>
      <desc>
        <marker id="driver_deq"></marker>
        <p>Dequeues data by moving the head pointer
          forward in the driver queue by <c>size</c> bytes. The data
          in the queue is deallocated.</p>
        <p>Returns the number of bytes remaining in the queue on success,
          otherwise <c>-1</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_enq(ErlDrvPort port, char* buf,
        ErlDrvSizeT len)</nametext></name>
      <fsummary>Enqueue data in the driver queue.</fsummary>
      <desc>
        <marker id="driver_enq"></marker>
        <p>Enqueues data in the driver queue. The data in
          <c>buf</c> is copied (<c>len</c> bytes) and placed at the
          end of the driver queue. The driver queue is normally used
          in a FIFO way.</p>
        <p>The driver queue is available to queue output from the
          emulator to the driver (data from the driver to the emulator
          is queued by the emulator in normal Erlang message
          queues). This can be useful if the driver must wait for
          slow devices, and so on, and wants to yield back to the
          emulator. The driver queue is implemented as an <c>ErlIOVec</c>.</p>
        <p>When the queue contains data, the driver does not close until
          the queue is empty.</p>
        <p>The return value is <c>0</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_enq_bin(ErlDrvPort port,
        ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)</nametext>
      </name>
      <fsummary>Enqueue binary in the driver queue.</fsummary>
      <desc>
        <marker id="driver_enq_bin"></marker>
        <p>Enqueues a driver binary in the driver
          queue. The data in <c>bin</c> at <c>offset</c> with length
          <c>len</c> is placed at the end of the queue. This function
          is most often faster than
          <seealso marker="#driver_enq"><c>driver_enq</c></seealso>,
          because no data must be copied.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_enqv(ErlDrvPort port, ErlIOVec *ev,
        ErlDrvSizeT skip)</nametext></name>
      <fsummary>Enqueue vector in the driver queue.</fsummary>
      <desc>
        <marker id="driver_enqv"></marker>
        <p>Enqueues the data in <c>ev</c>, skipping the
          first <c>skip</c> bytes of it, at the end of the driver
          queue. It is faster than
          <seealso marker="#driver_enq"><c>driver_enq</c></seealso>,
          because no data must be copied.</p>
        <p>The return value is <c>0</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_failure(ErlDrvPort port, int
        error)</nametext></name>
      <name><ret>int</ret><nametext>driver_failure_atom(ErlDrvPort port, char
        *string)</nametext></name>
      <name><ret>int</ret><nametext>driver_failure_posix(ErlDrvPort port, int
        error)</nametext></name>
      <fsummary>Fail with error.</fsummary>
      <desc>
        <marker id="driver_failure_atom"></marker>
        <marker id="driver_failure_posix"></marker>
        <marker id="driver_failure"></marker>
        <p>Signals to Erlang that the driver has
          encountered an error and is to be closed. The port is
          closed and the tuple <c>{'EXIT', error, Err}</c> is sent to
          the port owner process, where error is an error atom
          (<c>driver_failure_atom</c> and
          <c>driver_failure_posix</c>) or an integer
          (<c>driver_failure</c>).</p>
        <p>The driver is to fail only when in severe error situations,
          when the driver cannot possibly keep open, for example,
          buffer allocation gets out of memory. For normal errors
          it is more appropriate to send error codes with
          <seealso marker="#driver_output"><c>driver_output</c></seealso>.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_failure_eof(ErlDrvPort
        port)</nametext></name>
      <fsummary>Fail with EOF.</fsummary>
      <desc>
        <marker id="driver_failure_eof"></marker>
        <p>Signals to Erlang that the driver has
          encountered an EOF and is to be closed, unless the port was
          opened with option <c>eof</c>, in which case <c>eof</c> is sent
          to the port. Otherwise the port is closed and an
          <c>'EXIT'</c> message is sent to the port owner process.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>driver_free(void *ptr)</nametext></name>
      <fsummary>Free an allocated memory block.</fsummary>
      <desc>
        <marker id="driver_free"></marker>
        <p>Frees the memory pointed to by <c>ptr</c>. The
          memory is to have been allocated with
          <c>driver_alloc</c>. All allocated memory is to be
          deallocated, only once. There is no garbage collection in
          drivers.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret>
        <nametext>driver_free_binary(ErlDrvBinary *bin)</nametext></name>
      <fsummary>Free a driver binary.</fsummary>
      <desc>
        <marker id="driver_free_binary"></marker>
        <p>Frees a driver binary <c>bin</c>, allocated previously with
        <seealso marker="#driver_alloc_binary">
        <c>driver_alloc_binary</c></seealso>. As binaries
          in Erlang are reference counted, the binary can still be around.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTermData</ret>
        <nametext>driver_get_monitored_process(ErlDrvPort port, const
        ErlDrvMonitor *monitor)</nametext></name>
      <fsummary>Retrieve the process ID from a monitor.</fsummary>
      <desc>
        <marker id="driver_get_monitored_process"></marker>
        <p>Returns the process ID associated with a living
          monitor. It can be used in the
          <seealso marker="driver_entry#process_exit">
          <c>process_exit</c></seealso> callback to
          get the process identification for the exiting process.</p>
        <p>Returns <c>driver_term_nil</c> if the monitor no longer exists.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret>
        <nametext>driver_get_now(ErlDrvNowData *now)</nametext></name>
      <fsummary>Read a system time stamp.</fsummary>
      <desc>
        <marker id="driver_get_now"></marker>
	<warning>
          <p><em>This function is deprecated. Do not use it.</em> Use
            <seealso marker="#erl_drv_monotonic_time">
            <c>erl_drv_monotonic_time</c></seealso> (perhaps in combination with
            <seealso marker="#erl_drv_time_offset">
            <c>erl_drv_time_offset</c></seealso>) instead.</p>
        </warning>
        <p>Reads a time stamp into the memory pointed to by
          parameter <c>now</c>. For information about specific fields, see
          <seealso marker="#ErlDrvNowData"><c>ErlDrvNowData</c></seealso>.</p>
        <p>The return value is <c>0</c>, unless the <c>now</c> pointer is
          invalid, in which case it is &lt; <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_lock_driver(ErlDrvPort
        port)</nametext></name>
      <fsummary>Ensure the driver is never unloaded.</fsummary>
      <desc>
        <marker id="driver_lock_driver"></marker>
        <p>Locks the driver used by the port <c>port</c>
          in memory for the rest of the emulator process'
          lifetime. After this call, the driver behaves as one of Erlang's
          statically linked-in drivers.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTermData</ret><nametext>driver_mk_atom(char*
        string)</nametext></name>
      <fsummary>Make an atom from a name.</fsummary>
      <desc>
        <marker id="driver_mk_atom"></marker>
        <p>Returns an atom given a name
          <c>string</c>. The atom is created and does not change, so the
          return value can be saved and reused, which is faster than
          looking up the atom several times.</p>
        <p>Notice that this function is <em>not</em> thread-safe, not
          even when the emulator with SMP support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTermData</ret><nametext>driver_mk_port(ErlDrvPort
        port)</nametext></name>
      <fsummary>Make an Erlang term port from a port.</fsummary>
      <desc>
        <marker id="driver_mk_port"></marker>
        <p>Converts a port handle to the Erlang term format, usable in
          <seealso marker="#erl_drv_output_term">
          <c>erl_drv_output_term</c></seealso> and 
          <seealso marker="#erl_drv_send_term">
          <c>erl_drv_send_term</c></seealso>.</p>
        <p>Notice that this function is <em>not</em> thread-safe, not
          even when the emulator with SMP support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_monitor_process(ErlDrvPort port,
        ErlDrvTermData process, ErlDrvMonitor *monitor)</nametext></name>
      <fsummary>Monitor a process from a driver.</fsummary>
      <desc>
        <marker id="driver_monitor_process"></marker>
        <p>Starts monitoring a process from a driver. When a process is
          monitored, a process exit results in a call to the provided
          <seealso marker="driver_entry#process_exit">
          <c>process_exit</c></seealso> callback
          in the <seealso marker="driver_entry"><c>ErlDrvEntry</c></seealso>
          structure. The <c>ErlDrvMonitor</c> structure is filled in, for later
          removal or compare.</p>
        <p>Parameter <c>process</c> is to be the return value of an
          earlier call to <seealso marker="#driver_caller">
          <c>driver_caller</c></seealso> or
          <seealso marker="#driver_connected"><c>driver_connected</c></seealso>
          call.</p>
        <p>Returns <c>0</c> on success, &lt; 0 if no callback is
          provided, and &gt; 0 if the process is no longer alive.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_output(ErlDrvPort port, char *buf,
        ErlDrvSizeT len)</nametext></name>
      <fsummary>Send data from driver to port owner.</fsummary>
      <desc>
        <marker id="driver_output"></marker>
        <p>Sends data from the driver up to the emulator. The data is received
          as terms or binary data, depending on how the driver port was
          opened.</p>
        <p>The data is queued in the port owner process' message
          queue. Notice that this does not yield to the emulator (as
          the driver and the emulator run in the same thread).</p>
        <p>Parameter <c>buf</c> points to the data to send, and
          <c>len</c> is the number of bytes.</p>
        <p>The return value for all output functions is <c>0</c> for normal use.
          If the driver is used for distribution, it can fail and return
          <c>-1</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_output_binary(ErlDrvPort port, char
        *hbuf, ErlDrvSizeT hlen, ErlDrvBinary* bin, ErlDrvSizeT offset,
        ErlDrvSizeT len)</nametext></name>
      <fsummary>Send data from a driver binary to port owner.</fsummary>
      <desc>
        <marker id="driver_output_binary"></marker>
        <p>Sends data to a port owner process from a
          driver binary. It has a header buffer (<c>hbuf</c>
          and <c>hlen</c>) just like
          <seealso marker="#driver_output2"><c>driver_output2</c></seealso>.
          Parameter <c>hbuf</c> can be <c>NULL</c>.</p>
        <p>Parameter <c>offset</c> is an offset into the binary and
          <c>len</c> is the number of bytes to send.</p>
        <p>Driver binaries are created with
          <seealso marker="#driver_alloc_binary">
          <c>driver_alloc_binary</c></seealso>.</p>
        <p>The data in the header is sent as a list and the binary as
          an Erlang binary in the tail of the list.</p>
        <p>For example, if <c>hlen</c> is <c>2</c>, the port owner process
          receives <c><![CDATA[[H1, H2 | <<T>>]]]></c>.</p>
        <p>The return value is <c>0</c> for normal use.</p>
        <p>Notice that, using the binary syntax in Erlang, the driver
          application can match the header directly from the binary,
          so the header can be put in the binary, and <c>hlen</c> can be set
          to <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_output_term(ErlDrvPort port,
        ErlDrvTermData* term, int n)</nametext></name>
      <fsummary>Send term data from driver to port owner.</fsummary>
      <desc>
        <marker id="driver_output_term"></marker>
        <warning>
          <p><em>This function is deprecated.</em>
            Use <seealso marker="#erl_drv_send_term">
            <c>erl_drv_output_term</c></seealso>instead.</p>
        </warning>
        <p>Parameters <c>term</c> and <c>n</c> work as in
          <seealso marker="#erl_drv_output_term">
          <c>erl_drv_output_term</c></seealso>.</p>
        <p>Notice that this function is <em>not</em> thread-safe, not
          even when the emulator with SMP support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_output2(ErlDrvPort port, char *hbuf,
        ErlDrvSizeT hlen, char *buf, ErlDrvSizeT len)</nametext></name>
      <fsummary>Send data and binary data to port owner.</fsummary>
      <desc>
        <marker id="driver_output2"></marker>
        <p>First sends <c>hbuf</c>
          (length in <c>hlen</c>) data as a list, regardless of port
          settings. Then sends <c>buf</c> as a binary or list.
          For example, if <c>hlen</c> is <c>3</c>, the port owner process
          receives <c>[H1, H2, H3 | T]</c>.</p>
        <p>The point of sending data as a list header, is to facilitate
          matching on the data received.</p>
        <p>The return value is <c>0</c> for normal use.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_outputv(ErlDrvPort port, char* hbuf,
        ErlDrvSizeT hlen, ErlIOVec *ev, ErlDrvSizeT skip)</nametext></name>
      <fsummary>Send vectorized data to port owner.</fsummary>
      <desc>
        <marker id="driver_outputv"></marker>
        <p>Sends data from an I/O vector, <c>ev</c>, to
          the port owner process. It has a header buffer (<c>hbuf</c>
          and <c>hlen</c>), just like <seealso marker="#driver_output2">
          <c>driver_output2</c></seealso>.</p>
        <p>Parameter <c>skip</c> is a number of bytes to skip of
          the <c>ev</c> vector from the head.</p>
        <p>You get vectors of <c>ErlIOVec</c> type from the driver
          queue (see below), and the
          <seealso marker="driver_entry#outputv"><c>outputv</c></seealso>
          driver entry function. You can also make them yourself, if you want to
          send several <c>ErlDrvBinary</c> buffers at once. Often
          it is faster to use
          <seealso marker="#driver_output"><c>driver_output</c></seealso> or
          <seealso marker="#driver_output_binary"></seealso>.</p>
        <p>For example, if <c>hlen</c> is <c>2</c> and <c>ev</c> points to an
          array of three binaries, the port owner process receives
          <c><![CDATA[[H1, H2, <<B1>>, <<B2>> | <<B3>>]]]></c>.</p>
        <p>The return value is <c>0</c> for normal use.</p>
        <p>The comment for <c>driver_output_binary</c> also applies for
          <c>driver_outputv</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvPDL</ret>
        <nametext>driver_pdl_create(ErlDrvPort port)</nametext></name>
      <fsummary>Create a port data lock.</fsummary>
      <desc>
        <marker id="driver_pdl_create"></marker>
        <p>Creates a port data lock associated with the <c>port</c>.</p>
        <note>
          <p>Once a port data lock has been created, it must be locked during
            all operations on the driver queue of the <c>port</c>.</p>
        </note>
        <p>Returns a newly created port data lock on success,
          otherwise <c>NULL</c>. The function fails
          if <c>port</c> is invalid or if a port data lock already has
          been associated with the <c>port</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>long</ret><nametext>driver_pdl_dec_refc(ErlDrvPDL
        pdl)</nametext></name>
      <fsummary></fsummary>
      <desc>
        <marker id="driver_pdl_dec_refc"></marker>
        <p>Decrements the reference count of
          the port data lock passed as argument (<c>pdl</c>).</p>
        <p>The current reference count after the decrement has
          been performed is returned.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>long</ret>
        <nametext>driver_pdl_get_refc(ErlDrvPDL pdl)</nametext></name>
      <fsummary></fsummary>
      <desc>
        <marker id="driver_pdl_get_refc"></marker>
        <p>Returns the current reference count of
          the port data lock passed as argument (<c>pdl</c>).</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>long</ret>
        <nametext>driver_pdl_inc_refc(ErlDrvPDL pdl)</nametext></name>
      <fsummary></fsummary>
      <desc>
        <marker id="driver_pdl_inc_refc"></marker>
        <p>Increments the reference count of
          the port data lock passed as argument (<c>pdl</c>).</p>
        <p>The current reference count after the increment has
          been performed is returned.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret>
        <nametext>driver_pdl_lock(ErlDrvPDL pdl)</nametext></name>
      <fsummary>Lock port data lock.</fsummary>
      <desc>
        <marker id="driver_pdl_lock"></marker>
        <p>Locks the port data lock passed as argument (<c>pdl</c>).</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret>
        <nametext>driver_pdl_unlock(ErlDrvPDL pdl)</nametext></name>
      <fsummary>Unlock port data lock.</fsummary>
      <desc>
        <marker id="driver_pdl_unlock"></marker>
        <p>Unlocks the port data lock passed as argument (<c>pdl</c>).</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>SysIOVec *</ret><nametext>driver_peekq(ErlDrvPort port, int
        *vlen)</nametext></name>
      <fsummary>Get the driver queue as a vector.</fsummary>
      <desc>
        <marker id="driver_peekq"></marker>
        <p>Retrieves the driver queue as a pointer to an
          array of <c>SysIOVec</c>s. It also returns the number of
          elements in <c>vlen</c>. This is one of two ways to get data
          out of the queue.</p>
        <p>Nothing is removed from the queue by this function, that must be done
          with <seealso marker="#driver_deq"><c>driver_deq</c></seealso>.</p>
        <p>The returned array is suitable to use with the Unix system
          call <c>writev</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R15B"><ret>ErlDrvSizeT</ret><nametext>driver_peekqv(ErlDrvPort port,
        ErlIOVec *ev)</nametext></name>
      <fsummary>Get the driver queue as an I/O vector.</fsummary>
      <desc>
        <marker id="driver_peekqv"></marker>
        <p>Retrieves the driver queue into a supplied
	  <c>ErlIOVec</c> <c>ev</c>. It also returns the queue size.
	  This is one of two ways to get data out of the queue.</p>
	<p>If <c>ev</c> is <c>NULL</c>, all ones that is <c>-1</c> type cast to
	  <c>ErlDrvSizeT</c> are returned.</p>
        <p>Nothing is removed from the queue by this function, that must be done
          with <seealso marker="#driver_deq"><c>driver_deq</c></seealso>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_pushq(ErlDrvPort port, char* buf,
        ErlDrvSizeT len)</nametext></name>
      <fsummary>Push data at the head of the driver queue.</fsummary>
      <desc>
        <marker id="driver_pushq"></marker>
        <p>Puts data at the head of the driver queue. The
          data in <c>buf</c> is copied (<c>len</c> bytes) and placed
          at the beginning of the queue.</p>
        <p>The return value is <c>0</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_pushq_bin(ErlDrvPort port,
        ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)</nametext>
      </name>
      <fsummary>Push binary at the head of the driver queue.</fsummary>
      <desc>
        <marker id="driver_pushq_bin"></marker>
        <p>Puts data in the binary <c>bin</c>, at
          <c>offset</c> with length <c>len</c> at the head of the
          driver queue. It is most often faster than
          <seealso marker="#driver_pushq"><c>driver_pushq</c></seealso>,
          because no data must be copied.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_pushqv(ErlDrvPort port, ErlIOVec
        *ev, ErlDrvSizeT skip)</nametext></name>
      <fsummary>Push vector at the head of the driver queue.</fsummary>
      <desc>
        <marker id="driver_pushqv"></marker>
        <p>Puts the data in <c>ev</c>, skipping the first
          <c>skip</c> bytes of it, at the head of the driver queue.
          It is faster than
          <seealso marker="#driver_pushq"><c>driver_pushq</c></seealso>,
          because no data must be copied.</p>
        <p>The return value is <c>0</c>.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_read_timer(ErlDrvPort port, unsigned
        long *time_left)</nametext></name>
      <fsummary>Read the time left before time-out.</fsummary>
      <desc>
        <marker id="driver_read_timer"></marker>
        <p>Reads the current time of a timer, and places
          the result in <c>time_left</c>. This is the time in
          milliseconds, before the time-out occurs.</p>
        <p>The return value is <c>0</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>void *</ret>
        <nametext>driver_realloc(void *ptr, ErlDrvSizeT size)</nametext></name>
      <fsummary>Resize an allocated memory block.</fsummary>
      <desc>
        <marker id="driver_realloc"></marker>
        <p>Resizes a memory block, either in place, or by
          allocating a new block, copying the data, and freeing the old
          block. A pointer is returned to the reallocated memory. On
          failure (out of memory), <c>NULL</c> is returned. (This is
          most often a wrapper for <c>realloc</c>.)</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvBinary *</ret>
        <nametext>driver_realloc_binary(ErlDrvBinary *bin, ErlDrvSizeT size)
        </nametext></name>
      <fsummary>Resize a driver binary.</fsummary>
      <desc>
        <marker id="driver_realloc_binary"></marker>
        <p>Resizes a driver binary, while keeping the data.</p>
        <p>Returns the resized driver binary on success. Returns <c>NULL</c>
          on failure (out of memory).</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_select(ErlDrvPort port, ErlDrvEvent
        event, int mode, int on)</nametext></name>
      <fsummary>Provides an event for having the emulator call the driver.
      </fsummary>
      <desc>
        <marker id="driver_select"></marker>
        <p>This function is used by drivers to provide the emulator with
          events to check for. This enables the emulator to call the driver
          when something has occurred asynchronously.</p>
        <p>Parameter <c>event</c> identifies an OS-specific event object.
          On Unix systems, the functions <c>select</c>/<c>poll</c> are used.
          The event object must be a socket or pipe (or other object that
          <c>select</c>/<c>poll</c> can use).
          On Windows, the Win32 API function <c>WaitForMultipleObjects</c>
          is used. This places other restrictions on the event object;
          see the Win32 SDK documentation.</p>
        <p>Parameter <c>on</c> is to be <c>1</c> for setting events
          and <c>0</c> for clearing them.</p>
        <p>Parameter <c>mode</c> is a bitwise OR combination of
          <c>ERL_DRV_READ</c>, <c>ERL_DRV_WRITE</c>, and <c>ERL_DRV_USE</c>.
          The first two specify whether to wait for read events and/or write
          events. A fired read event calls
          <seealso marker="driver_entry#ready_input">
          <c>ready_input</c></seealso> and a fired write event calls
          <seealso marker="driver_entry#ready_output">
          <c>ready_output</c></seealso>.</p>
        <note>
          <p>Some OS (Windows) do not differentiate between read and write
            events. The callback for a fired event then only depends on the
            value of <c>mode</c>.</p>
        </note>
        <p><c>ERL_DRV_USE</c> specifies if we are using the event object or
          if we want to close it.
          On an emulator with SMP support, it is not safe to clear all events
          and then close the event object after <c>driver_select</c> has
          returned. Another thread can still be using the event object
          internally. To safely close an event object, call
          <c>driver_select</c> with <c>ERL_DRV_USE</c> and <c>on==0</c>, which
          clears all events and then either calls
	  <seealso marker="driver_entry#stop_select"><c>stop_select</c></seealso>
	  or schedules it to be called when it is safe to close the event
          object. <c>ERL_DRV_USE</c> is to be set together with the first event
          for an event object. It is harmless to set <c>ERL_DRV_USE</c>
          even if it already has been done. Clearing all events but keeping
          <c>ERL_DRV_USE</c> set indicates that we are using the event
          object and probably will set events for it again.</p>
        <note>
          <p><c>ERL_DRV_USE</c> was added in Erlang/OTP R13. Old drivers still
            work as before, but it is recommended to update them to use
            <c>ERL_DRV_USE</c> and <c>stop_select</c> to ensure that event
            objects are closed in a safe way.</p>
        </note>
        <p>The return value is <c>0</c>, unless
          <c>ready_input</c>/<c>ready_output</c> is <c>NULL</c>, in which case
          it is <c>-1</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_send_term(ErlDrvPort port,
        ErlDrvTermData receiver, ErlDrvTermData* term, int n)</nametext></name>
      <fsummary>Send term data to other process than port owner process.
      </fsummary>
      <desc>
        <marker id="driver_send_term"></marker>
        <warning>
          <p><em>This function is deprecated.</em>
            Use <seealso marker="#erl_drv_send_term">
            <c>erl_drv_send_term</c></seealso> instead.</p>
        </warning>
        <note>
          <p>The parameters of this function
            cannot be properly checked by the runtime system when
            executed by arbitrary threads. This can cause the
            function not to fail when it should.</p>
        </note>
        <p>Parameters <c>term</c> and <c>n</c> work as in
          <seealso marker="#erl_drv_output_term">
          <c>erl_drv_output_term</c></seealso>.</p>
        <p>This function is only thread-safe when the emulator with SMP
          support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>driver_set_timer(ErlDrvPort port, unsigned
        long time)</nametext></name>
      <fsummary>Set a timer to call the driver.</fsummary>
      <desc>
        <marker id="driver_set_timer"></marker>
        <p>Sets a timer on the driver, which will count
          down and call the driver when it is timed out. Parameter
          <c>time</c> is the time in milliseconds before the timer expires.</p>
        <p>When the timer reaches <c>0</c> and expires, the driver entry
          function <seealso marker="driver_entry#timeout">
          <c>timeout</c></seealso> is called.</p>
        <p>Notice that only one timer exists on each driver instance;
          setting a new timer replaces an older one.</p>
        <p>Return value is <c>0</c>, unless the <c>timeout</c>
          driver function is <c>NULL</c>, in which case it is <c>-1</c>.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvSizeT</ret>
        <nametext>driver_sizeq(ErlDrvPort port)</nametext></name>
      <fsummary>Return the size of the driver queue.</fsummary>
      <desc>
        <marker id="driver_sizeq"></marker>
        <p>Returns the number of bytes currently in the driver queue.</p>
        <p>This function can be called from any thread if a
          <seealso marker="#ErlDrvPDL">port data lock</seealso>
          associated with the <c>port</c> is locked by the calling
          thread during the call.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>driver_system_info(ErlDrvSysInfo
        *sys_info_ptr, size_t size)</nametext></name>
      <fsummary>Get information about the Erlang runtime system.</fsummary>
      <desc>
        <marker id="driver_system_info"></marker>
        <p>Writes information about the Erlang runtime system into the
          <seealso marker="#ErlDrvSysInfo"><c>ErlDrvSysInfo</c></seealso>
          structure referred to by the first argument. The second
          argument is to be the size of the
          <seealso marker="#ErlDrvSysInfo"><c>ErlDrvSysInfo</c></seealso>
          structure, that is, <c>sizeof(ErlDrvSysInfo)</c>.</p>
        <p>For information about specific fields, see
          <seealso marker="#ErlDrvSysInfo"><c>ErlDrvSysInfo</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvSizeT</ret><nametext>driver_vec_to_buf(ErlIOVec *ev,
        char *buf, ErlDrvSizeT len)</nametext></name>
      <fsummary>Collect data segments into a buffer.</fsummary>
      <desc>
        <marker id="driver_vec_to_buf"></marker>
        <p>Collects several segments of data, referenced
          by <c>ev</c>, by copying them in order to the buffer
          <c>buf</c>, of the size <c>len</c>.</p>
        <p>If the data is to be sent from the driver to the port owner
          process, it is faster to use
          <seealso marker="#driver_outputv"><c>driver_outputv</c></seealso>.</p>
        <p>The return value is the space left in the buffer, that is, if
          <c>ev</c> contains less than <c>len</c> bytes it is the
          difference, and if <c>ev</c> contains <c>len</c> bytes or more,
          it is <c>0</c>. This is faster if there is more than one header byte,
          as the binary syntax can construct integers directly from
          the binary.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B"><ret>void</ret><nametext>erl_drv_busy_msgq_limits(ErlDrvPort port,
        ErlDrvSizeT *low, ErlDrvSizeT *high)</nametext></name>
      <fsummary>Set and get limits for busy port message queue.</fsummary>
      <desc>
        <marker id="erl_drv_busy_msgq_limits"></marker>
        <p>Sets and gets limits that will be used for controlling the
          busy state of the port message queue.</p>
        <p>The port message queue is set into a busy
          state when the amount of command data queued on the
          message queue reaches the <c>high</c> limit. The port
          message queue is set into a not busy state when the
          amount of command data queued on the message queue falls
          below the <c>low</c> limit. Command data is in this
          context data passed to the port using either
          <c>Port ! {Owner, {command, Data}}</c> or
          <c>port_command/[2,3]</c>. Notice that these limits
          only concerns command data that have not yet reached the
          port. The <seealso marker="#set_busy_port">busy port</seealso>
          feature can be used for data that has reached the port.</p>
        <p>Valid limits are values in the range
          <c>[ERL_DRV_BUSY_MSGQ_LIM_MIN, ERL_DRV_BUSY_MSGQ_LIM_MAX]</c>.
          Limits are automatically adjusted to be sane. That is,
          the system adjusts values so that the low limit used is
          lower than or equal to the high limit used. By default the high
          limit is 8 kB and the low limit is 4 kB.</p>
        <p>By passing a pointer to an integer variable containing
          the value <c>ERL_DRV_BUSY_MSGQ_READ_ONLY</c>, the currently used
          limit is read and written back to the integer variable.
          A new limit can be set by passing a pointer to an integer
          variable containing a valid limit. The passed value is
          written to the internal limit. The internal limit is then
          adjusted. After this the adjusted limit is written
          back to the integer variable from which the new value was
          read. Values are in bytes.</p>
        <p>The busy message queue feature can be disabled either
          by setting the <c>ERL_DRV_FLAG_NO_BUSY_MSGQ</c>
          <seealso marker="driver_entry#driver_flags">driver flag</seealso>
          in the <seealso marker="driver_entry"><c>driver_entry</c></seealso>
          used by the driver, or by calling this function with
          <c>ERL_DRV_BUSY_MSGQ_DISABLED</c> as a limit (either low or
          high). When this feature has been disabled, it cannot be
          enabled again. When reading the limits, both are
          <c>ERL_DRV_BUSY_MSGQ_DISABLED</c> if this
          feature has been disabled.</p>
        <p>Processes sending command data to the port are suspended
          if either the port is busy or if the port message queue is
          busy. Suspended processes are resumed when neither the
          port or the port message queue is busy.</p>
        <p>For information about busy port functionality, see
          <seealso marker="#set_busy_port"><c>set_busy_port</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_cond_broadcast(ErlDrvCond
        *cnd)</nametext></name>
      <fsummary>Broadcast on a condition variable.</fsummary>
      <desc>
        <marker id="erl_drv_cond_broadcast"></marker>
        <p>Broadcasts on a condition variable. That is, if
          other threads are waiting on the condition variable being
          broadcast on, <em>all</em> of them are woken.</p>
        <p><c>cnd</c> is a pointer to a condition variable to broadcast on.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvCond *</ret><nametext>erl_drv_cond_create(char
        *name)</nametext></name>
      <fsummary>Create a condition variable.</fsummary>
      <desc>
        <marker id="erl_drv_cond_create"></marker>
        <p>Creates a condition variable and returns a pointer to it.</p> 
        <p><c>name</c> is a string identifying the created condition variable.
          It is used to identify the condition variable in planned
          future debug functionality.</p>
        <p>Returns <c>NULL</c> on failure. The driver
          creating the condition variable is responsible for
          destroying it before the driver is unloaded.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_cond_destroy(ErlDrvCond
        *cnd)</nametext></name>
      <fsummary>Destroy a condition variable.</fsummary>
      <desc>
        <marker id="erl_drv_cond_destroy"></marker>
        <p>Destroys a condition variable previously created by
          <seealso marker="#erl_drv_cond_create">
          <c>erl_drv_cond_create</c></seealso>.</p>
        <p><c>cnd</c> is a pointer to a condition variable to destroy.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B02"><ret>char *</ret><nametext>erl_drv_cond_name(ErlDrvCond
        *cnd)</nametext></name>
      <fsummary>Get name of driver mutex.</fsummary>
      <desc>
        <marker id="erl_drv_cnd_name"></marker>
        <p>Returns a pointer to the name of the condition.</p>
        <p><c>cnd</c> is a  pointer to an initialized condition.</p>
        <note>
          <p>This function is intended for debugging purposes only.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_cond_signal(ErlDrvCond
        *cnd)</nametext></name>
      <fsummary>Signal on a condition variable.</fsummary>
      <desc>
        <marker id="erl_drv_cond_signal"></marker>
        <p>Signals on a condition variable. That is, if
          other threads are waiting on the condition variable being
          signaled, <em>one</em> of them is woken.</p>
        <p><c>cnd</c> is a pointer to a condition variable to signal on.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_cond_wait(ErlDrvCond *cnd,
        ErlDrvMutex *mtx)</nametext></name>
      <fsummary>Wait on a condition variable.</fsummary>
      <desc>
        <marker id="erl_drv_cond_wait"></marker>
        <p>Waits on a condition variable. The calling
          thread is blocked until another thread wakes it by signaling
          or broadcasting on the condition variable. Before the calling
          thread is blocked, it unlocks the mutex passed as argument.
          When the calling thread is woken, it locks the same mutex before
          returning. That is, the mutex currently must be locked by
          the calling thread when calling this function.</p>
        <p><c>cnd</c> is a pointer to a condition variable to wait on.
          <c>mtx</c> is a pointer to a mutex to unlock while waiting.</p>
        <note>
          <p><c>erl_drv_cond_wait</c> can return even if
            no one has signaled or broadcast on the condition
            variable. Code calling <c>erl_drv_cond_wait</c> is
            always to be prepared for <c>erl_drv_cond_wait</c>
            returning even if the condition that the thread was
            waiting for has not occurred. That is, when returning from
            <c>erl_drv_cond_wait</c>, always check if the condition
            has occurred, and if not call <c>erl_drv_cond_wait</c>  again.</p>
        </note>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B"><ret>int</ret><nametext>erl_drv_consume_timeslice(ErlDrvPort port,
        int percent)</nametext></name>
      <fsummary>Give the runtime system a hint about how much CPU time the
        current driver callback call has consumed.</fsummary>
      <desc>
        <marker id="erl_drv_consume_timeslice"></marker>
        <p>Gives the runtime system a hint about how much CPU time the current
          driver callback call has consumed since the last hint, or since the
          the start of the callback if no previous hint has been given.</p>
        <taglist>
          <tag><c>port</c></tag>
          <item>Port handle of the executing port.</item>
          <tag><c>percent</c></tag>
          <item>Approximate consumed fraction of a full
            time-slice in percent.</item>
        </taglist>
        <p>The time is specified as a fraction, in percent, of a full time-slice
          that a port is allowed to execute before it is to surrender the
          CPU to other runnable ports or processes. Valid range is
          <c>[1, 100]</c>. The scheduling time-slice is not an exact entity,
          but can usually be approximated to about 1 millisecond.</p>
        <p>Notice that it is up to the runtime system to determine if and
          how to use this information. Implementations on some platforms
          can use other means to determine the consumed fraction
          of the time-slice. Lengthy driver callbacks should, regardless of
          this, frequently call this function to determine if it is allowed
          to continue execution or not.</p>
        <p>This function returns a non-zero value
          if the time-slice has been exhausted, and zero if the callback is
          allowed to continue execution. If a non-zero value is
          returned, the driver callback is to return as soon as possible in
          order for the port to be able to yield.</p>
        <p>This function is provided to better support co-operative scheduling,
          improve system responsiveness, and to make it easier to prevent
          misbehaviors of the VM because of a port monopolizing a scheduler
          thread. It can be used when dividing lengthy work into some repeated
          driver callback calls, without the need to use threads.</p>
        <p>See also the important <seealso marker="#WARNING">warning</seealso>
          text at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since="OTP 18.3"><ret>ErlDrvTime</ret><nametext>erl_drv_convert_time_unit(ErlDrvTime
        val, ErlDrvTimeUnit from, ErlDrvTimeUnit to)</nametext></name>
      <fsummary>Convert time unit of a time value.</fsummary>
      <desc>
        <marker id="erl_drv_convert_time_unit"></marker>
        <p>Converts the <c>val</c> value of time unit <c>from</c> to
          the corresponding value of time unit <c>to</c>. The result is
          rounded using the floor function.</p>
        <taglist>
          <tag><c>val</c></tag>
          <item>Value to convert time unit for.</item>
          <tag><c>from</c></tag>
          <item>Time unit of <c>val</c>.</item>
          <tag><c>to</c></tag>
          <item>Time unit of returned value.</item>
        </taglist>
        <p>Returns <c>ERL_DRV_TIME_ERROR</c> if called with an invalid
          time unit argument.</p>
        <p>See also <seealso marker="#ErlDrvTime">
          <c>ErlDrvTime</c></seealso> and
          <seealso marker="#ErlDrvTimeUnit">
          <c>ErlDrvTimeUnit</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_equal_tids(ErlDrvTid tid1,
        ErlDrvTid tid2)</nametext></name>
      <fsummary>Compare thread identifiers for equality.</fsummary>
      <desc>
        <marker id="erl_drv_equal_tids"></marker>
        <p>Compares two thread identifiers, <c>tid1</c> and <c>tid2</c>,
          for equality.</p>
        <p>Returns <c>0</c> it they are not equal, and a value not equal to
          <c>0</c> if they are equal.</p>
        <note>
          <p>A thread identifier can be reused very quickly after
            a thread has terminated. Therefore, if a thread
            corresponding to one of the involved thread identifiers
            has terminated since the thread identifier was saved,
            the result of <c>erl_drv_equal_tids</c> does possibly not give
            the expected result.</p>
        </note>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_getenv(const char *key, char
        *value, size_t *value_size)</nametext></name>
      <fsummary>Get the value of an environment variable.</fsummary>
      <desc>
        <marker id="erl_drv_getenv"></marker>
        <p>Retrieves the value of an environment variable.</p>
        <taglist>
          <tag><c>key</c></tag>
          <item>A <c>NULL</c>-terminated string containing the
            name of the environment variable.</item>
          <tag><c>value</c></tag>
          <item>A pointer to an output buffer.</item>
          <tag><c>value_size</c></tag>
          <item>A pointer to an integer. The integer is used both for
            passing input and output sizes (see below).</item>
        </taglist>
        <p>When this function is called, <c>*value_size</c> is to contain the
          size of the <c>value</c> buffer.</p>
        <p>On success, <c>0</c> is returned,
          the value of the environment variable has been written to
          the <c>value</c> buffer, and <c>*value_size</c> contains the
          string length (excluding the terminating <c>NULL</c> character) of
          the value written to the <c>value</c> buffer.</p>
        <p>On failure, that is, no such environment variable was found,
          a value &lt; <c>0</c> is returned. When the size of the <c>value</c>
          buffer is too small, a value &gt; <c>0</c> is returned and
          <c>*value_size</c> has been set to the buffer size needed.</p>
        <warning>
          <p>This function reads the emulated environment used by
            <seealso marker="os:getenv/1"><c>os:getenv/1</c></seealso> and not
            the environment used by libc's <c>getenv(3)</c> or similar. Drivers
            that <em>require</em> that these are in sync will need to do so
            themselves, but keep in mind that they are segregated for a reason;
            <c>getenv(3)</c> and its friends are <em>not thread-safe</em> and
            may cause unrelated code to misbehave or crash the emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP 19.0"><ret>void</ret><nametext>erl_drv_init_ack(ErlDrvPort port,
        ErlDrvData res)</nametext></name>
      <fsummary>Acknowledge the start of the port.</fsummary>
      <desc>
        <marker id="erl_drv_init_ack"></marker>
        <p>Acknowledges the start of the port.</p>
        <taglist>
          <tag><c>port</c></tag>
          <item>The port handle of the port (driver instance)
            doing the acknowledgment.
	  </item>
          <tag><c>res</c></tag>
          <item>The result of the port initialization. Can be the same
            values as the return value of <seealso marker="driver_entry#start">
            <c>start</c></seealso>, that is, any of the error codes or the
            <c>ErlDrvData</c> that is to be used for this port.
          </item>
        </taglist>
        <p>When this function is called the initiating <c>erlang:open_port</c>
          call is returned as if the <seealso marker="driver_entry#start">
          <c>start</c></seealso> function had just been called. It can only be
          used when flag <seealso marker="driver_entry#driver_flags">
          <c>ERL_DRV_FLAG_USE_INIT_ACK</c></seealso>
          has been set on the linked-in driver.</p>
      </desc>
    </func>

    <func>
      <name since="OTP 18.3"><ret>ErlDrvTime</ret>
        <nametext>erl_drv_monotonic_time(ErlDrvTimeUnit time_unit)</nametext>
      </name>
      <fsummary>Get Erlang monotonic time.</fsummary>
      <desc>
        <marker id="erl_drv_monotonic_time"></marker>
        <p>Returns <seealso marker="time_correction#Erlang_Monotonic_Time">
          Erlang monotonic time</seealso>. Notice that negative values are
          not uncommon.</p>
        <p><c>time_unit</c> is time unit of returned value.</p>
        <p>Returns <c>ERL_DRV_TIME_ERROR</c> if called with an invalid
          time unit argument, or if called from a thread that is not a
          scheduler thread.</p>
        <p>See also <seealso marker="#ErlDrvTime"><c>ErlDrvTime</c></seealso>
          and <seealso marker="#ErlDrvTimeUnit">
          <c>ErlDrvTimeUnit</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvMutex *</ret><nametext>erl_drv_mutex_create(char
        *name)</nametext></name>
      <fsummary>Create a mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_create"></marker>
        <p>Creates a mutex and returns a pointer to it.</p>
        <p><c>name</c> is a string identifying the created mutex. It is used
          to identify the mutex in planned future debug functionality.</p>
        <p>Returns <c>NULL</c> on failure. The driver creating the mutex is
          responsible for destroying it before the driver is unloaded.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_mutex_destroy(ErlDrvMutex
        *mtx)</nametext></name>
      <fsummary>Destroy a mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_destroy"></marker>
        <p>Destroys a mutex previously created by
          <seealso marker="#erl_drv_mutex_create">
          <c>erl_drv_mutex_create</c></seealso>.
          The mutex must be in an unlocked state before it is destroyed.</p>
        <p><c>mtx</c> is a pointer to a mutex to destroy.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_mutex_lock(ErlDrvMutex
        *mtx)</nametext></name>
      <fsummary>Lock a mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_lock"></marker>
        <p>Locks a mutex. The calling thread is blocked until the mutex has
          been locked. A thread that has currently locked the mutex
          <em>cannot</em> lock the same mutex again.</p>
        <p><c>mtx</c> is a pointer to a mutex to lock.</p>
        <warning>
          <p>If you leave a mutex locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B02"><ret>char *</ret><nametext>erl_drv_mutex_name(ErlDrvMutex
        *mtx)</nametext></name>
      <fsummary>Get name of driver mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_name"></marker>
        <p>Returns a pointer to the mutex name.</p>
        <p><c>mtx</c> is a pointer to an initialized mutex.</p>
        <note>
          <p>This function is intended for debugging purposes only.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_mutex_trylock(ErlDrvMutex
        *mtx)</nametext></name>
      <fsummary>Try lock a mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_trylock"></marker>
        <p>Tries to lock a mutex. A thread that has currently locked the mutex
          <em>cannot</em> try to lock the same mutex again.</p>
        <p><c>mtx</c> is a pointer to a mutex to try to lock.</p>
        <p>Returns <c>0</c> on success, otherwise <c>EBUSY</c>.</p>
        <warning>
          <p>If you leave a mutex locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_mutex_unlock(ErlDrvMutex
        *mtx)</nametext></name>
      <fsummary>Unlock a mutex.</fsummary>
      <desc>
        <marker id="erl_drv_mutex_unlock"></marker>
        <p>Unlocks a mutex. The mutex currently must be
          locked by the calling thread.</p>
        <p><c>mtx</c> is a pointer to a mutex to unlock.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B"><ret>int</ret><nametext>erl_drv_output_term(ErlDrvTermData port,
        ErlDrvTermData* term, int n)</nametext></name>
      <fsummary>Send term data from driver to port owner.</fsummary>
      <desc>
        <marker id="erl_drv_output_term"></marker>
        <p>Sends data in the special driver term
          format to the port owner process. This is a fast way to
          deliver term data from a driver. It needs no binary
          conversion, so the port owner process receives data as
          normal Erlang terms. The <seealso marker="#erl_drv_send_term">
          <c>erl_drv_send_term</c></seealso>
          functions can be used for sending to any process
          on the local node.</p>
        <note>
          <p>Parameter <c>port</c> is <em>not</em>
            an ordinary port handle, but a port handle converted using
            <seealso marker="#driver_mk_port">
            <c>driver_mk_port</c></seealso>.</p>
        </note>
        <p>Parameter <c>term</c> points to an array of
          <c>ErlDrvTermData</c> with <c>n</c> elements. This array
          contains terms described in the driver term format. Every
          term consists of 1-4 elements in the array. The
          first term has a term type and then arguments.
          Parameter <c>port</c> specifies the sending port.</p>
        <p>Tuples, maps, and lists (except strings, see below)
          are built in reverse polish notation, so that to build a
          tuple, the elements are specified first, and then the tuple
          term, with a count. Likewise for lists and maps.</p>
        <list type="bulleted">
          <item>
            <p>A tuple must be specified with the number of elements. (The
              elements precede the <c>ERL_DRV_TUPLE</c> term.)</p>
          </item>
          <item>
            <p>A map must be specified with the number of key-value pairs
              <c>N</c>. The key-value pairs must precede the <c>ERL_DRV_MAP</c>
              in this order: <c>key1,value1,key2,value2,...,keyN,valueN</c>.
              Duplicate keys are not allowed.</p>
          </item>
          <item>
            <p>A list must be specified with the number of elements,
              including the tail, which is the last term preceding
              <c>ERL_DRV_LIST</c>.</p>
          </item>
        </list>
        <p>The special term <c>ERL_DRV_STRING_CONS</c> is used to
          "splice" in a string in a list, a string specified this way is
          not a list in itself, but the elements are elements of the
          surrounding list.</p>
        <pre>
Term type            Arguments
---------            ---------
ERL_DRV_NIL
ERL_DRV_ATOM         ErlDrvTermData atom (from driver_mk_atom(char *string))
ERL_DRV_INT          ErlDrvSInt integer
ERL_DRV_UINT         ErlDrvUInt integer
ERL_DRV_INT64        ErlDrvSInt64 *integer_ptr
ERL_DRV_UINT64       ErlDrvUInt64 *integer_ptr
ERL_DRV_PORT         ErlDrvTermData port (from driver_mk_port(ErlDrvPort port))
ERL_DRV_BINARY       ErlDrvBinary *bin, ErlDrvUInt len, ErlDrvUInt offset
ERL_DRV_BUF2BINARY   char *buf, ErlDrvUInt len
ERL_DRV_STRING       char *str, int len
ERL_DRV_TUPLE        int sz
ERL_DRV_LIST         int sz
ERL_DRV_PID          ErlDrvTermData pid (from driver_connected(ErlDrvPort port)
                     or driver_caller(ErlDrvPort port))
ERL_DRV_STRING_CONS  char *str, int len
ERL_DRV_FLOAT        double *dbl
ERL_DRV_EXT2TERM     char *buf, ErlDrvUInt len
ERL_DRV_MAP          int sz</pre>
	<p>The unsigned integer data type <c>ErlDrvUInt</c> and the
	  signed integer data type <c>ErlDrvSInt</c> are 64 bits wide
	  on a 64-bit runtime system and 32 bits wide on a 32-bit
	  runtime system. They were introduced in ERTS 5.6
	  and replaced some of the <c>int</c> arguments in the list above.</p>
	<p>The unsigned integer data type <c>ErlDrvUInt64</c> and the
	  signed integer data type <c>ErlDrvSInt64</c> are always 64 bits
	  wide. They were introduced in ERTS 5.7.4.</p>
	<p>To build the tuple <c>{tcp, Port, [100 | Binary]}</c>, the
	  following call can be made.</p>
	<code type="none"><![CDATA[
ErlDrvBinary* bin = ...
ErlDrvPort port = ...
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("tcp"),
    ERL_DRV_PORT, driver_mk_port(drvport),
        ERL_DRV_INT, 100,
        ERL_DRV_BINARY, bin, 50, 0,
        ERL_DRV_LIST, 2,
    ERL_DRV_TUPLE, 3,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    ]]></code>
        <p>Here <c>bin</c> is a driver binary of length at least 50 and
          <c>drvport</c> is a port handle. Notice that <c>ERL_DRV_LIST</c>
          comes after the elements of the list, likewise
          <c>ERL_DRV_TUPLE</c>.</p>
        <p>The <c>ERL_DRV_STRING_CONS</c> term is a way to construct
          strings. It works differently from how <c>ERL_DRV_STRING</c>
          works. <c>ERL_DRV_STRING_CONS</c> builds a string list in
          reverse order (as opposed to how <c>ERL_DRV_LIST</c>
          works), concatenating the strings added to a list. The tail
          must be specified before <c>ERL_DRV_STRING_CONS</c>.</p>
        <p><c>ERL_DRV_STRING</c> constructs a string, and ends
          it. (So it is the same as <c>ERL_DRV_NIL</c> followed by
          <c>ERL_DRV_STRING_CONS</c>.)</p>
        <code type="none"><![CDATA[
/* to send [x, "abc", y] to the port: */
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("x"),
    ERL_DRV_STRING, (ErlDrvTermData)"abc", 3,
    ERL_DRV_ATOM, driver_mk_atom("y"),
    ERL_DRV_NIL,
    ERL_DRV_LIST, 4
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    ]]></code>
        <code type="none"><![CDATA[
/* to send "abc123" to the port: */
ErlDrvTermData spec[] = {
    ERL_DRV_NIL,        /* with STRING_CONS, the tail comes first */
    ERL_DRV_STRING_CONS, (ErlDrvTermData)"123", 3,
    ERL_DRV_STRING_CONS, (ErlDrvTermData)"abc", 3,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    ]]></code>
	<p>The <c>ERL_DRV_EXT2TERM</c> term type is used for passing a
	  term encoded with the
	  <seealso marker="erl_ext_dist">external format</seealso>,
	  that is, a term that has been encoded by
	  <seealso marker="erlang#term_to_binary/2">
	  <c>erlang:term_to_binary</c></seealso>,
	  <seealso marker="erl_interface:ei"><c>erl_interface:ei(3)</c></seealso>,
	  and so on.
	  For example, if <c>binp</c> is a pointer to an <c>ErlDrvBinary</c>
	  that contains term <c>{17, 4711}</c> encoded with the
	  <seealso marker="erl_ext_dist">external format</seealso>,
	  and you want to wrap it in a two-tuple with the tag <c>my_tag</c>,
	  that is, <c>{my_tag, {17, 4711}}</c>, you can do as follows:</p>
	<code type="none"><![CDATA[
ErlDrvTermData spec[] = {
        ERL_DRV_ATOM, driver_mk_atom("my_tag"),
        ERL_DRV_EXT2TERM, (ErlDrvTermData) binp->orig_bytes, binp->orig_size
    ERL_DRV_TUPLE, 2,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    ]]></code>
        <p>To build the map <c>#{key1 => 100, key2 => {200, 300}}</c>, the
          following call can be made.</p>
        <code type="none"><![CDATA[
ErlDrvPort port = ...
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("key1"),
        ERL_DRV_INT, 100,
    ERL_DRV_ATOM, driver_mk_atom("key2"),
        ERL_DRV_INT, 200,
        ERL_DRV_INT, 300,
    ERL_DRV_TUPLE, 2,
    ERL_DRV_MAP, 2
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    ]]></code>
        <p>If you want to pass a binary and do not already have the content
          of the binary in an <c>ErlDrvBinary</c>, you can benefit from using
          <c>ERL_DRV_BUF2BINARY</c> instead of creating an <c>ErlDrvBinary</c>
          through <seealso marker="#driver_alloc_binary">
          <c>driver_alloc_binary</c></seealso> and then pass the binary through
          <c>ERL_DRV_BINARY</c>. The runtime system often allocates
          binaries smarter if <c>ERL_DRV_BUF2BINARY</c> is used.
          However, if the content of the binary to pass already resides in
          an <c>ErlDrvBinary</c>, it is normally better to pass the binary using
          <c>ERL_DRV_BINARY</c> and the <c>ErlDrvBinary</c> in question.</p>
        <p>The <c>ERL_DRV_UINT</c>, <c>ERL_DRV_BUF2BINARY</c>, and
          <c>ERL_DRV_EXT2TERM</c> term types were introduced in
          ERTS 5.6.</p>
        <p>This function is only thread-safe when the emulator with SMP
          support is used.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_putenv(const char *key, char
        *value)</nametext></name>
      <fsummary>Set the value of an environment variable.</fsummary>
      <desc>
        <marker id="erl_drv_putenv"></marker>
        <p>Sets the value of an environment variable.</p>
        <p><c>key</c> is a <c>NULL</c>-terminated string containing the
          name of the environment variable.</p>
        <p><c>value</c> is a <c>NULL</c>-terminated string containing the
          new value of the environment variable.</p>
        <p>Returns <c>0</c> on success, otherwise a value <c>!= 0</c>.</p>
        <note>
          <p>The result of passing the empty string (<c>""</c>) as a value
            is platform-dependent. On some platforms the variable value
            is set to the empty string, on others the
            environment variable is removed.</p>
        </note>
        <warning>
          <p>This function modifies the emulated environment used by
            <seealso marker="os:putenv/2"><c>os:putenv/2</c></seealso> and not
            the environment used by libc's <c>putenv(3)</c> or similar. Drivers
            that <em>require</em> that these are in sync will need to do so
            themselves, but keep in mind that they are segregated for a reason;
            <c>putenv(3)</c> and its friends are <em>not thread-safe</em> and
            may cause unrelated code to misbehave or crash the emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvRWLock *</ret><nametext>erl_drv_rwlock_create(char
        *name)</nametext></name>
      <fsummary>Create an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_create"></marker>
        <p>Creates an rwlock and returns a pointer to it.</p>
        <p><c>name</c> is a string identifying the created rwlock.
          It is used to identify the rwlock in planned future
          debug functionality.</p>
        <p>Returns <c>NULL</c> on failure. The driver creating the rwlock
          is responsible for destroying it before the driver is unloaded.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_rwlock_destroy(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Destroy an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_destroy"></marker>
        <p>Destroys an rwlock previously created by
          <seealso marker="#erl_drv_rwlock_create">
          <c>erl_drv_rwlock_create</c></seealso>.
          The rwlock must be in an unlocked state before it is destroyed.</p>
        <p><c>rwlck</c> is a pointer to an rwlock to destroy.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B02"><ret>char *</ret><nametext>erl_drv_rwlock_name(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Get name of driver mutex.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_name"></marker>
        <p>Returns a pointer to the name of the rwlock.</p>
        <p><c>rwlck</c> is a pointer to an initialized rwlock.</p>
        <note>
          <p>This function is intended for debugging purposes only.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_rwlock_rlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Read lock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_rlock"></marker>
        <p>Read locks an rwlock. The calling thread is
          blocked until the rwlock has been read locked. A thread
          that currently has read or read/write locked the rwlock
          <em>cannot</em> lock the same rwlock again.</p>
        <p><c>rwlck</c> is a pointer to the rwlock to read lock.</p>
        <warning>
          <p>If you leave an rwlock locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_rwlock_runlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Read unlock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_runlock"></marker>
        <p>Read unlocks an rwlock. The rwlock currently must
          be read locked by the calling thread.</p>
        <p><c>rwlck</c> is a pointer to an rwlock to read unlock.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_rwlock_rwlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Read/write lock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_rwlock"></marker>
        <p>Read/write locks an rwlock. The calling thread
          is blocked until the rwlock has been read/write locked.
          A thread that currently has read or read/write locked the
          rwlock <em>cannot</em> lock the same rwlock again.</p>
        <p><c>rwlck</c> is a pointer to an rwlock to read/write lock.</p>
        <warning>
          <p>If you leave an rwlock locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
          </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_rwlock_rwunlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Read/write unlock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_rwunlock"></marker>
        <p>Read/write unlocks an rwlock. The rwlock currently must be
          read/write locked by the calling thread.</p>
        <p><c>rwlck</c> is a pointer to an rwlock to read/write unlock.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_rwlock_tryrlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Try to read lock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_tryrlock"></marker>
        <p>Tries to read lock an rwlock.</p>
        <p><c>rwlck</c> is a pointer to an rwlock to try to read lock.</p>
        <p>Returns <c>0</c> on success, otherwise <c>EBUSY</c>.
          A thread that currently has read or read/write locked the
          rwlock <em>cannot</em> try to lock the same rwlock again.</p>
        <warning>
          <p>If you leave an rwlock locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_rwlock_tryrwlock(ErlDrvRWLock
        *rwlck)</nametext></name>
      <fsummary>Try to read/write lock an rwlock.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_tryrwlock"></marker>
        <p>Tries to read/write lock an rwlock.
          A thread that currently has read or read/write locked the
          rwlock <em>cannot</em> try to lock the same rwlock again.</p>
        <p><c>rwlck</c>is pointer to an rwlock to try to read/write lock.</p>
        <p>Returns <c>0</c> on success, otherwise <c>EBUSY</c>.</p>
        <warning>
          <p>If you leave an rwlock locked in an emulator thread
            when you let the thread out of your control, you will
            <em>very likely</em> deadlock the whole emulator.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B"><ret>int</ret><nametext>erl_drv_send_term(ErlDrvTermData port,
        ErlDrvTermData receiver, ErlDrvTermData* term, int n)</nametext></name>
      <fsummary>Send term data to other process than port owner process.
      </fsummary>
      <desc>
        <marker id="erl_drv_send_term"></marker>
        <p>This function is the only way for a driver to send data to
          <em>other</em> processes than the port owner process. Parameter
          <c>receiver</c> specifies the process to receive the data.</p>
        <note>
          <p>Parameter <c>port</c> is <em>not</em> an ordinary port handle, but
            a port handle converted using
            <seealso marker="#driver_mk_port">
            <c>driver_mk_port</c></seealso>.</p>
        </note>
        <p>Parameters <c>port</c>, <c>term</c>, and <c>n</c> work as in
          <seealso marker="#erl_drv_output_term">
          <c>erl_drv_output_term</c></seealso>.</p>
        <p>This function is only thread-safe when the emulator with SMP
          support is used.</p>
      </desc>
    </func>

    <func>
      <name since="OTP 19.0"><ret>void</ret><nametext>erl_drv_set_os_pid(ErlDrvPort port,
        ErlDrvSInt pid)</nametext></name>
      <fsummary>Set the os_pid for the port.</fsummary>
      <desc>
        <marker id="erl_drv_set_os_pid"></marker>
        <p>Sets the <c>os_pid</c> seen when doing
          <seealso marker="erlang:port_info/2">
          <c>erlang:port_info/2</c></seealso> on this port.</p>
        <p><c>port</c> is the port handle of the port (driver instance) to set
          the pid on. <c>pid</c>is the pid to set.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_thread_create(char *name, ErlDrvTid
        *tid, void * (*func)(void *), void *arg, ErlDrvThreadOpts
        *opts)</nametext></name>
      <fsummary>Create a thread.</fsummary>
      <desc>
        <marker id="erl_drv_thread_create"></marker>
        <p>Creates a new thread.</p>
        <taglist>
          <tag><c>name</c></tag>
          <item>A string identifying the created thread. It is used to
            identify the thread in planned future debug functionality.
          </item>
          <tag><c>tid</c></tag>
          <item>A pointer to a thread identifier variable.</item>
          <tag><c>func</c></tag>
          <item>A pointer to a function to execute in the created thread.</item>
          <tag><c>arg</c></tag>
          <item>A pointer to argument to the <c>func</c> function.</item>
          <tag><c>opts</c></tag>
          <item>A pointer to thread options to use or <c>NULL</c>.</item>
        </taglist>
        <p>Returns <c>0</c> on success,
          otherwise an <c>errno</c> value is returned to indicate the error.
          The newly created thread begins executing in the function pointed
          to by <c>func</c>, and <c>func</c> is passed <c>arg</c> as
          argument. When <c>erl_drv_thread_create</c> returns, the thread
          identifier of the newly created thread is available in
          <c>*tid</c>. <c>opts</c> can be either a <c>NULL</c> pointer, or a
          pointer to an
          <seealso marker="#ErlDrvThreadOpts"><c>ErlDrvThreadOpts</c></seealso>
          structure. If <c>opts</c> is a <c>NULL</c> pointer, default options
          are used, otherwise the passed options are used.</p>
        <warning>
          <p>You are not allowed to allocate the
            <seealso marker="#ErlDrvThreadOpts">
            <c>ErlDrvThreadOpts</c></seealso> structure by yourself.
            It must be allocated and initialized by
            <seealso marker="#erl_drv_thread_opts_create">
            <c>erl_drv_thread_opts_create</c></seealso>.</p>
        </warning>
        <p>The created thread terminates either when <c>func</c> returns or if
          <seealso marker="#erl_drv_thread_exit">
          <c>erl_drv_thread_exit</c></seealso>
          is called by the thread. The exit value of the thread is either
          returned from <c>func</c> or passed as argument to
          <seealso marker="#erl_drv_thread_exit">
          <c>erl_drv_thread_exit</c></seealso>.
          The driver creating the thread is responsible for joining the
          thread, through <seealso marker="#erl_drv_thread_join">
          <c>erl_drv_thread_join</c></seealso>,
          before the driver is unloaded. "Detached" threads cannot be created,
          that is, threads that do not need to be joined.</p>
        <warning>
          <p>All created threads must be joined by the driver before
            it is unloaded. If the driver fails to join all threads
            created before it is unloaded, the runtime system
            most likely crashes when the driver code is unloaded.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_thread_exit(void
        *exit_value)</nametext></name>
      <fsummary>Terminate calling thread.</fsummary>
      <desc>
        <marker id="erl_drv_thread_exit"></marker>
        <p>Terminates the calling thread with the exit value passed as
          argument. <c>exit_value</c> is a pointer to an exit value or
          <c>NULL</c>.</p>
        <p>You are only allowed to terminate threads created with
          <seealso marker="#erl_drv_thread_create">
          <c>erl_drv_thread_create</c></seealso>.</p>
        <p>The exit value can later be retrieved by another thread through
          <seealso marker="#erl_drv_thread_join">
          <c>erl_drv_thread_join</c></seealso>.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_thread_join(ErlDrvTid tid, void
        **exit_value)</nametext></name>
      <fsummary>Join with another thread.</fsummary>
      <desc>
        <marker id="erl_drv_thread_join"></marker>
        <p>Joins the calling thread with another thread, that is,
          the calling thread is blocked until the thread identified by
          <c>tid</c> has terminated.</p>
        <p><c>tid</c> is the thread identifier of the thread to join.
          <c>exit_value</c> is a pointer to a pointer to an exit value,
          or <c>NULL</c>.</p>
        <p>Returns <c>0</c> on success, otherwise an <c>errno</c>
          value is returned to indicate the error.</p>
        <p>A thread can only be joined once. The behavior of joining
          more than once is undefined, an emulator crash is likely. If
          <c>exit_value == NULL</c>, the exit value of the terminated thread
          is ignored, otherwise the exit value of the terminated thread
          is stored at <c>*exit_value</c>.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R16B02"><ret>char *</ret><nametext>erl_drv_thread_name(ErlDrvTid
        tid)</nametext></name>
      <fsummary>Get name of driver mutex.</fsummary>
      <desc>
        <marker id="erl_drv_rwlock_name"></marker>
        <p>Returns a pointer to the name of the thread.</p>
        <p><c>tid</c> is a thread identifier.</p>
        <note>
          <p>This function is intended for debugging purposes only.</p>
        </note>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvThreadOpts *</ret>
        <nametext>erl_drv_thread_opts_create(char *name)</nametext></name>
      <fsummary>Create thread options.</fsummary>
      <desc>
        <marker id="erl_drv_thread_opts_create"></marker>
        <p>Allocates and initializes a thread option structure.</p>
        <p><c>name</c> is a string identifying the created thread options.
          It is used to identify the thread options in planned future debug
          functionality.</p>
        <p>Returns <c>NULL</c> on failure. A thread option
          structure is used for passing options to
          <seealso marker="#erl_drv_thread_create">
          <c>erl_drv_thread_create</c></seealso>.
          If the structure is not modified before it is passed to
          <seealso marker="#erl_drv_thread_create">
          <c>erl_drv_thread_create</c></seealso>,
          the default values are used.</p>
        <warning>
          <p>You are not allowed to allocate the
            <seealso marker="#ErlDrvThreadOpts">
            <c>ErlDrvThreadOpts</c></seealso>
            structure by yourself. It must be allocated and initialized by
            <c>erl_drv_thread_opts_create</c>.</p>
          </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret>
        <nametext>erl_drv_thread_opts_destroy(ErlDrvThreadOpts *opts)</nametext>
      </name>
      <fsummary>Destroy thread options.</fsummary>
      <desc>
        <marker id="erl_drv_thread_opts_destroy"></marker>
        <p>Destroys thread options previously created by
          <seealso marker="#erl_drv_thread_opts_create">
          <c>erl_drv_thread_opts_create</c></seealso>.</p>
        <p><c>opts</c> is a pointer to thread options to destroy.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>ErlDrvTid</ret>
        <nametext>erl_drv_thread_self(void)</nametext></name>
      <fsummary>Get the thread identifier of the current thread.</fsummary>
      <desc>
        <marker id="erl_drv_thread_self"></marker>
        <p>Returns the thread identifier of the calling thread.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name since="OTP 18.3"><ret>ErlDrvTime</ret><nametext>erl_drv_time_offset(ErlDrvTimeUnit
        time_unit)</nametext></name>
      <fsummary>Get current time offset.</fsummary>
      <desc>
        <marker id="erl_drv_time_offset"></marker>
        <p>Returns the current time offset between
          <seealso marker="time_correction#Erlang_Monotonic_Time">
          Erlang monotonic time</seealso> and
          <seealso marker="time_correction#Erlang_System_Time">
          Erlang system time</seealso>
          converted into the <c>time_unit</c> passed as argument.</p>
        <p><c>time_unit</c> is time unit of returned value.</p>
        <p>Returns <c>ERL_DRV_TIME_ERROR</c> if called with an invalid
          time unit argument, or if called from a thread that is not a
          scheduler thread.</p>
        <p>See also <seealso marker="#ErlDrvTime">
          <c>ErlDrvTime</c></seealso> and
          <seealso marker="#ErlDrvTimeUnit">
          <c>ErlDrvTimeUnit</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>void *</ret><nametext>erl_drv_tsd_get(ErlDrvTSDKey
        key)</nametext></name>
      <fsummary>Get thread-specific data.</fsummary>
      <desc>
        <marker id="erl_drv_tsd_get"></marker>
        <p>Returns the thread-specific data
          associated with <c>key</c> for the calling thread.</p>
        <p><c>key</c> is a thread-specific data key.</p>
        <p>Returns <c>NULL</c> if no data has been associated
          with <c>key</c> for the calling thread.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>erl_drv_tsd_key_create(char *name,
        ErlDrvTSDKey *key)</nametext></name>
      <fsummary>Create a thread-specific data key.</fsummary>
      <desc>
        <marker id="erl_drv_tsd_key_create"></marker>
        <p>Creates a thread-specific data key.</p>
        <p><c>name</c> is a string identifying the created key. It is used
          to identify the key in planned future debug functionality.</p>
        <p><c>key</c> is a pointer to a thread-specific data key variable.</p>
        <p>Returns <c>0</c> on success, otherwise an <c>errno</c> value is
          returned to indicate the error. The driver creating the key is
          responsible for destroying it before the driver is unloaded.</p>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_tsd_key_destroy(ErlDrvTSDKey
        key)</nametext></name>
      <fsummary>Destroy a thread-specific data key.</fsummary>
      <desc>
        <marker id="erl_drv_tsd_key_destroy"></marker>
        <p>Destroys a thread-specific data key previously created by
          <seealso marker="#erl_drv_tsd_key_create">
          <c>erl_drv_tsd_key_create</c></seealso>.
          All thread-specific data using this key in all threads
          must be cleared (see <seealso marker="#erl_drv_tsd_set">
          <c>erl_drv_tsd_set</c></seealso>)
	  before the call to <c>erl_drv_tsd_key_destroy</c>.</p>
        <p><c>key</c> is a thread-specific data key to destroy.</p>
        <warning>
          <p>A destroyed key is very likely to be reused soon.
            Therefore, if you fail to clear the thread-specific
            data using this key in a thread before destroying
            the key, you will <em>very likely</em> get unexpected
            errors in other parts of the system.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>erl_drv_tsd_set(ErlDrvTSDKey key, void
        *data)</nametext></name>
      <fsummary>Set thread-specific data.</fsummary>
      <desc>
        <marker id="erl_drv_tsd_set"></marker>
        <p>Sets thread-specific data associated with
          <c>key</c> for the calling thread. You are only allowed to set
          thread-specific data for threads while they are fully under your
          control. For example, if you set thread-specific data in a thread
          calling a driver callback function, it must be cleared, that is,
          set to <c>NULL</c>, before returning from the driver callback
          function.</p>
        <p><c>key</c> is a thread-specific data key.</p>
        <p><c>data</c> is a pointer to data to associate with <c>key</c>
          in the calling thread.</p>
        <warning>
          <p>If you fail to clear thread-specific data in an
            emulator thread before letting it out of your control,
            you might never be able to clear this data with
            later unexpected errors in other parts of the system as
            a result.</p>
        </warning>
        <p>This function is thread-safe.</p>
      </desc>
    </func>

    <func>
      <name><ret>char *</ret><nametext>erl_errno_id(int error)</nametext></name>
      <fsummary>Get Erlang error atom name from error number.</fsummary>
      <desc>
        <marker id="erl_errno_id"></marker>
        <p>Returns the atom name of the Erlang error,
          given the error number in <c>error</c>. The error atoms are
          <c>einval</c>, <c>enoent</c>, and so on. It can be used to make
          error terms from the driver.</p>
      </desc>
    </func>

    <func>
      <name><ret>int</ret><nametext>remove_driver_entry(ErlDrvEntry
        *de)</nametext></name>
      <fsummary>Remove a driver entry.</fsummary>
      <desc>
        <marker id="remove_driver_entry"></marker>
        <p>Removes a driver entry <c>de</c> previously added with
          <seealso marker="#add_driver_entry">
          <c>add_driver_entry</c></seealso>.</p>
        <p>Driver entries added by the <c>erl_ddll</c> Erlang interface
          cannot be removed by using this interface.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>set_busy_port(ErlDrvPort port, int
        on)</nametext></name>
      <fsummary>Signal or unsignal port as busy.</fsummary>
      <desc>
        <marker id="set_busy_port"></marker>
        <p>Sets and unsets the busy state of the port. If
          <c>on</c> is non-zero, the port is set to busy. If it is zero,
          the port is set to not busy. You typically want to combine
          this feature with the <seealso marker="#erl_drv_busy_msgq_limits">
          busy port message queue</seealso> functionality.</p>
        <p>Processes sending command data to the port are suspended
          if either the port or the port message queue
          is busy. Suspended processes are resumed when neither the
          port or the port message queue is busy. Command data
          is in this context data passed to the port using either
          <c>Port ! {Owner, {command, Data}}</c> or
          <c>port_command/[2,3]</c>.</p>
        <p>If the <seealso marker="driver_entry#driver_flags">
          <![CDATA[ERL_DRV_FLAG_SOFT_BUSY]]></seealso> has been set in the
          <seealso marker="driver_entry"><c>driver_entry</c></seealso>,
          data can be forced into the driver through
          <seealso marker="erlang#port_command/3">
          <c>erlang:port_command(Port, Data, [force])</c></seealso>
          even if the driver has signaled that it is busy.</p>
        <p>For information about busy port message queue functionality, see
          <seealso marker="#erl_drv_busy_msgq_limits">
          <c>erl_drv_busy_msgq_limits</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name><ret>void</ret><nametext>set_port_control_flags(ErlDrvPort port,
        int flags)</nametext></name>
      <fsummary>Set flags on how to handle control entry function.</fsummary>
      <desc>
        <marker id="set_port_control_flags"></marker>
        <p>Sets flags for how the <seealso marker="driver_entry#control">
          <c>control</c></seealso> driver entry
          function will return data to the port owner process.
          (The <c>control</c> function is called from
          <seealso marker="erlang:port_control/3">
          <c>erlang:port_control/3</c></seealso>.)</p>
        <p>Currently there are only two meaningful values for
          <c>flags</c>: <c>0</c> means that data is returned in a list,
          and <c>PORT_CONTROL_FLAG_BINARY</c> means data is returned as
          a binary from <c>control</c>.</p>
      </desc>
    </func>
  </funcs>

  <section>
    <title>See Also</title>
    <p><seealso marker="driver_entry"><c>driver_entry(3)</c></seealso>,
      <seealso marker="erlang"><c>erlang(3)</c></seealso>,
      <seealso marker="kernel:erl_ddll"><c>erl_ddll(3)</c></seealso>,
      section <seealso marker="alt_dist">How to Implement an Alternative
      Carrier for the Erlang Distribution</seealso> in the User's Guide</p>
  </section>
</cref>