|Developer(s)||Open Handset Alliance|
|Initial release||September 23, 2008|
|Platform||x86, x86-64, ARM, ARM64, MIPS, MIPS64|
|Type||C standard library|
|License||Three-clause BSD licence|
Bionic is the standard C library (including libc, libdl, libm, and libpthread) developed by Google for its Android operating system. Bionic is a BSD-licensed C library for use with the Linux kernel. This differs from other BSD C libraries which require a BSD kernel, and from the GNU C Library (glibc) which uses the GNU Lesser General Public License.
- BSD-licensed: Google wanted to isolate Android applications from the effect of copyleft licenses to create a proprietary user-space and application ecosystem, but:
- Android is based on the Linux kernel, which is subject to the copyleft GNU General Public License (GPL) version 2.
- The most widespread standard C library for the Linux kernel is the GNU C Library (glibc), which is subject to the GNU Lesser General Public License (LGPL), also a copyleft license. In contrast to the GPL, the LGPL explicitly allows for dynamic linking but it does not allow static linking of proprietary software.
- The permissive BSD license is a non-copyleft license that is compatible in both directions. A BSD-licensed glibc substitute could act as an isolation layer between the copyleft core (kernel) and the non-copyleft applications, and was therefore chosen by Google for its Bionic as a glibc substitute.
- Small size: Bionic was much smaller than the GNU C Library; more importantly its memory requirements were (and remain) much lower.
- Speed: Bionic was designed for CPUs at relatively low clock frequencies.
Bionic only supports Linux kernels, but currently supports the arm, arm64, mips, mips64, x86, and x86-64 architectures. The platform itself requires armv7 with NEON since KitKat, though the NDK supported armv5 (which it called armeabi) as recently as NDK r16, and still supports armv7 both with and without NEON. Historically there was partial SH-4 support in the platform, but no devices ever shipped and support has since been removed. The NDK never supported SH-4, and MIPS and MIPS64 support have been removed from the NDK.
The dynamic memory allocator implementation has changed over time. Before Lollipop there was a single native memory allocator, dlmalloc. For Lollipop and Marshmallow there were two implementations: dlmalloc and jemalloc. jemalloc gives much higher performance than dlmalloc, but at the cost of extra memory required for bookkeeping. Most devices used jemalloc but low-memory devices still used dlmalloc. For Nougat and later releases, all devices uses jemalloc. Low-memory devices use a "svelte" configuration of jemalloc that disables the tcache to nearly match the lower memory overhead of dlmalloc while keeping most of the speed of jemalloc.
Some 64-bit devices, like the Nexus 9, are effectively low-memory devices because of the extra space requirements of 64-bit pointers and hosting of two zygotes. (Zygote is an Android system service that is the parent of all Android application processes.)
The dynamic linker (and libdl) were written from scratch.
Bionic doesn't include libthread_db (used by gdbserver), but the NDK does. The Android platform includes a statically-linked gdbserver so developers can use the latest gdb even on old devices.
There is no separate libpthread, libresolv, or librt on Android – the functionality is all in libc. For libpthread, there's no attempt to optimize for the single-threaded case because apps are in a multi-threaded environment even before the first instruction of third-party code is ever run.
The Android platform uses libc++ for the C++ standard library (releases up to and including Lollipop used stlport). The NDK currently offers stlport, libc++, and the GNU STL.
Differences from POSIX
Although bionic aims to implement all of C11 and POSIX, there are still (as of Oreo) about 70 POSIX functions missing from libc. There are also POSIX functions such as the endpwent/getpwent/setpwent family that are inapplicable to Android because it lacks a passwd database. As of Oreo, libm is complete.
Some functions deliberately do not conform to the POSIX or C standards for security reasons, such as printf which does not support the
%n format string.
Many of the most-used GNU extensions are implemented in bionic, as are various BSD extensions.
Relationship to the NDK
Platform code uses bionic directly, but third-party developers use the Android Native Development Kit (NDK). Many third-party developers still target older OS releases, which contributes to a widespread belief that bionic lacks many features. Gingerbread exported 803 functions from libc but Oreo exports 1278 (a 1.6x increase).
Historically the NDK and the platform diverged, but NDK r11 and later have replaced NDK forks with their current platform equivalents. This work initially focused on the GCC and clang compilers.
Prior to NDK r14, when "unified" headers were first offered on an opt-in basis, the NDK had forked copies of the platform headers for different API levels. This meant that header-only fixes (fixes to constant or structure definitions, for example) weren't available to most NDK users because they'd be targeting an older API level, but platform fixes were only going in to the current platform headers. In the Oreo development period the platform headers were annotated with API level information so that the same set of headers can be used for all API levels, with only those functions available at the developer's targeted API level being visible. These are the so-called "unified" headers, and have been the default since NDK r15.
Prior to NDK r16, the NDK linked a library called libandroid_support.a to code using libc++. This provided functions required by libc++ that weren't in old OS releases. This wasn't the same code used by the platform and introduced numerous bugs (such as breaking positional arguments to the printf family in any code that used libc++). In NDK r16 libandroid_support.a still exists, but is now built directly from platform source (current at the time the NDK is built).
As of Android Jelly Bean MR1 (4.2), bionic supports similar functionality to glibc's
_FORTIFY_SOURCE, which is a feature where unsafe string and memory functions (such as
memcpy()) include checks for buffer overruns. These checks are performed at compile time if the buffer sizes can be determined at compile time, or run-time otherwise. Because fortify relies on runtime support from libc, its portability to older Android releases is limited. The platform itself is built with
Historically, one of the shortcomings of fortify has been that it's closely tied with gcc, which makes it very difficult to support well in other compilers, like Clang. This meant that when Android swapped to Clang as its default compiler, bionic's fortify implementation became substantially less useful. In Android Oreo (8.0), bionic's fortify was overhauled with Clang in mind, resulting in fortify on Clang providing an experience on par with fortify on gcc. Since this overhaul, some checks were added above and beyond glibc's to catch code that -- while not necessarily causing undefined behavior -- is obviously incorrect. Because this new implementation requires no more libc support than the prior one, the clang-specific enhancements are available to applications targeting versions of Android before Oreo.
For the creation of Bionic, Google used GPLv2-licensed Linux kernel header files. To get rid of the GPL, Google claimed that it cleaned the header files from any copyright-able work, reducing them to non-copyrightable "facts". Google's behaviour was considered by Linus Torvalds as acceptable, but their interpretation of the GPL has been challenged, for instance by Raymond Nimmer, a law professor at the University of Houston Law Center.
- "Announcing the Android 1.0 SDK, release 1". September 9, 2008. Retrieved September 21, 2012.
- "Android Anatomy and Physiology" (PDF). Google I/O. 2008-05-28. Archived from the original (PDF) on 2016-04-08. Retrieved 2014-05-23.
- Burnette, Ed (June 4, 2008). "Patrick Brady dissects Android". ZDNet.
- Turner, David (2009-02-07). "Questions about Bionic".
The name "Bionic" comes from the fact that it is part-BSD and part-Linux: its source code consists in a mix of BSD C library pieces with custom Linux-specific bits used to deal with threads, processes, signals and a few others things.
- Anatomy-Physiology-of-an-Android (PDF), archived from the original (PDF) on 2016-04-08, retrieved 2017-07-15,
License: we want to keep GPL out of user-space (p. 36)
- Florian Mueller. "FOSS Patents".
- "Zygote". Anatomy of Android.
- "Android bionic status".
- Elliott Hughes. "libc: #define to remove support for %n from printf(3)?".
- "Jelly Bean". Android Developers. android.com. Retrieved 2013-12-27.
- "Android 4.2 and FORTIFY_SOURCE". Android Security Discussions. groups.google.com. Retrieved 2013-12-27.
- "Android NDK changelog". Android NDK. android.googlesource.com. Retrieved 2017-08-28.
- "FORTIFY in Android". Android Developers Blog. android-developers.googleblog.com. Retrieved 2017-08-28.
- Google android and the linux headers on theregister.com (2011)
- Android: Sued by Microsoft, not by Linux "Microsoft launches new Android suit, Linus Torvalds' take on Linux kernel headers and Android" on ITworld (March 21, 2011)
- Infringement and disclosure risk in development on copyleft platforms on ipinfoblog.com by Raymond Nimmer (2011)