About linux kernel in android

How do I submit patches to Android Common Kernels

BEST: Make all of your changes to upstream Linux. If appropriate, backport to the stable releases. These patches will be merged automatically in the corresponding common kernels. If the patch is already in upstream Linux, post a backport of the patch that conforms to the patch requirements below.

• Do not send patches upstream that contain only symbol exports. To be considered for upstream Linux, additions of EXPORT_SYMBOL_GPL() require an in-tree modular driver that uses the symbol — so include the new driver or changes to an existing driver in the same patchset as the export.
• When sending patches upstream, the commit message must contain a clear case for why the patch is needed and beneficial to the community. Enabling out-of-tree drivers or functionality is not not a persuasive case.

LESS GOOD: Develop your patches out-of-tree (from an upstream Linux point-of-view). Unless these are fixing an Android-specific bug, these are very unlikely to be accepted unless they have been coordinated with kernel-team@android.com. If you want to proceed, post a patch that conforms to the patch requirements below.

Common Kernel patch requirements

• All patches must conform to the Linux kernel coding standards and pass scripts/checkpatch.pl
• Patches shall not break gki_defconfig or allmodconfig builds for arm, arm64, x86, x86_64 architectures (see https://source.android.com/setup/build/building-kernels)
• If the patch is not merged from an upstream branch, the subject must be tagged with the type of patch: UPSTREAM: , BACKPORT: , FROMGIT: , FROMLIST: , or ANDROID: .
• All patches must have a Change-Id: tag (see https://gerrit-review.googlesource.com/Documentation/user-changeid.html)
• If an Android bug has been assigned, there must be a Bug: tag.
• All patches must have a Signed-off-by: tag by the author and the submitter

Additional requirements are listed below based on patch type

Requirements for backports from mainline Linux: UPSTREAM: , BACKPORT:

• If the patch is a cherry-pick from Linux mainline with no changes at all
  • tag the patch subject with UPSTREAM: .
  • add upstream commit information with a (cherry picked from commit . ) line
  • Example:
    • if the upstream commit message is

• then Joe Smith would upload the patch for the common kernel as

• If the patch requires any changes from the upstream version, tag the patch with BACKPORT: instead of UPSTREAM: .
  • use the same tags as UPSTREAM:
  • add comments about the changes under the (cherry picked from commit . ) line
  • Example:

Requirements for other backports: FROMGIT: , FROMLIST: ,

• If the patch has been merged into an upstream maintainer tree, but has not yet been merged into Linux mainline
  • tag the patch subject with FROMGIT:
  • add info on where the patch came from as (cherry picked from commit
    ) . This must be a stable maintainer branch (not rebased, so don’t use linux-next for example).
  • if changes were required, use BACKPORT: FROMGIT:
  • Example:
    • if the commit message in the maintainer tree is

• then Joe Smith would upload the patch for the common kernel as

Источник

На каком Android работает ядро ​​Linux?

Есть ли список версий ядра, которые есть в каждой версии Android AOSP?

Или скажем, какую версию / proc / version выложат.

Версия для Linux в AOSP

Таблица составлена ​​из:

Примечание: другие «дистрибутивы» Android могут работать с разными версиями ядра.

Любой желающий может исправить и расширить эту таблицу. Пожалуйста, продолжайте форматирование.

Почему ОС Android / версия ядра не совпадают

OEM-производители, как правило, поставляют свои основные обновления Android с ядром, аналогичным тому, с которым устройство было выпущено изначально. Это, скорее всего, позволит избежать проблем несовместимости оборудования и драйверов с более новым ядром. Например, устройство, которое было обновлено для работы с Android 8.0 Oreo, но первоначально поставлялось с 6.0 Marshmallow, все еще может работать под управлением Linux 3.18.x вместо Linux 4.10.x.

Требования Vendor Test Suite (VTS) для версии Linux

Один аспект, который был до OEM — это версия ядра Linux, но это меняется с Android Oreo.

До тех пор, пока OEM-производитель мог проходить сертификационные тесты, которые выкладывает Google, им было все равно, какая версия ядра использовалась в новом устройстве. Как правило, это не было проблемой, так как большинство OEM-производителей использовали бы ту же версию ядра для того поколения, которую использовали другие OEM-производители, поскольку она сильно привязана к тому, что поддерживают драйверы оборудования. Тем не менее, некоторые провалились в трещины, и это стало причиной проблем с безопасностью. Это то, что Google воспринимает всерьез в последнее время, поэтому имеет смысл, что они захотят начать поручать это.

Начиная с этого года со смартфонами, которые поставляются с Android Oreo, Google требует, чтобы все SoC, выпущенные в 2017 году, были запущены с ядром 4.4 или новее.

В настоящее время существующие устройства, которые обновлены до Android Oreo, должны работать только на ядре версии 3.18 или новее, и их не нужно обновлять для поддержки Project Treble.

Источник

EduApps-CDG / Building Linux Kernel With Android.md

How to Build Linux Kernel with Android

This guide shows how to build Linux on a Android Device and was made for people that doesn’t have s Computer.

• 4GB of free space (2GB if delete the temp files)
• Android 5.0

Preparing the Environment

You need to install Termux from Google Play Store. Now we will download the Kernel so we need WGET:

The next step is decompress that tarball with UNXZ and TAR (integrated with Termux):

(Optional) Delete the Linux tarball:

Now we have the Linux Source on our Android, lets compile!

In Android, compile is a terror for Linux Kernel. First we need to create a config file.

The .config file dilemma

If you had an Linux PC you could simply do this:

But you dont have so we need to do this:

If you have a Rooted Potato Phone you can simply:

No Root mode (medium)

If else, first you need to download it from our repository:

No Root mode (hard)

If the file was not found, you must generate it. It has only one command, but this command is the worst! It’s the best choice if you are developing a new device. Complete the first command of Building and type:

Once solved the dilemma, you will not need to do it again. the next step is install the compilers:

This command will setup to build the Kernel with full power, if you have a single core device, it doesn’t help so much but works:

And finally, the Last Step is: Enjoy the building time and drink a coffee!

Источник

Google to Add Mainline Linux Kernel Support to Android

Last updated November 25, 2019 By John Paul 4 Comments

The current Android ecosystem is polluted with hundreds of different versions of Android, each running a different variant of the Linux kernel. Each version is designed for a different phone and it’s different configurations. Google has been working to fix the problem by adding the mainline Linux kernel to Android.

How the Linux kernel is currently handled in Android

Before it reaches you, the Linux kernel on your cellphone goes through three major steps.

First, Google takes the LTS (Long Term Support) version of the Linux kernel and adds all of the Android-specific code. This becomes the “Android Common kernel”.

Google then sends this code to the company that creates the System on a Chip (SoC) that runs your phone. This is usually Qualcomm.

Once the SoC maker finishes add code to support the CPU and other chips, the kernel is then passed on to the actual device maker, such as Samsung or Motorola. The device maker then adds code to support the rest of the phone, such as the display and camera.

Each of these steps takes a while to complete and results in a kernel that won’t work with any other device. It also means that the kernel is very old, usually about two years old. For example, the Google Pixel 4, which shipped last month, has a kernel from November 2017, which will never get updated.

Google has pledged to create security patches for older devices, which means they’re stuck keeping an eye on a huge hodge-podge of old code.

The Future

Last year, Google announced plans to fix this mess. This year they revealed what progress they made at the 2019 Linux Plumbers Conference.

“We know what it takes to run Android but not necessarily on any given hardware. So our goal is to basically find all of that out, then upstream it and try to be as close to mainline as possible.”

They did show off a Xiaomi Poco F1 running Android with a proper Linux kernel. However, it some things did not appear to be working, such as the battery percentage which was stuck at 0%.

So, how does Google plan to make this work? By taking a page from their Project Treble playbook. Before Project Treble, the low-level code that interacted with the device and Android itself was one big mess of code. Project Treble separated the two and made them modular so that Android updates could be shipped quicker and the low-level code could remain unchanged between updates.

Google wants to bring the same modularity to the kernel. Their plan “involves stabilizing Linux’s in-kernel ABI and having a stable interface for the Linux kernel and hardware vendors to write to. Google wants to decouple the Linux kernel from its hardware support.”

So this means that Google would ship a kernel and hardware drivers would be loaded as kernel modules. Currently, this is just a proposal. There are still quite a few technical problems that have to be solved. so, this won’t happen any time soon.

Opposition from Open Source

The Open Source community will not be happy with the idea of putting proprietary code in the kernel. The Linux kernel guidelines state that drivers have to have a GPL license to be included in the kernel. They also point out that if a change in the driver causes an error, it will be resolved by the person who created the error. This means less work for device makers in the long run.

Final Thoughts on including mainline kernel to Andorid

So far, this is just a proposal. There is a good chance that Google will start working on the project only to abandon it once they realize how much work this will take. Just take a look at how many projects Google has already abandoned.

Android Police made a good point by mentioned that Google is working on its Fuchsia operating system, which seems to have the goal of replacing Android one day.

So, the question is which monumental task will Google try to complete, getting Android running with a mainline Linux kernel or complete work on their unified Android replacement? Only time can answer that.

What are your thoughts on this topic? Please let us know in the comments below.

If you found this article interesting, please take a minute to share it on social media, Hacker News or Reddit.

Like what you read? Please share it with others.

Источник

Android Kernel Features

Contents

Kernel features unique to Android

In the course of development, Google developers made some changes to the Linux kernel. The amount of changes is not extremely large, and is on the order of changes that are customarily made to the Linux kernel by embedded developers (approximately 250 patches, with about 3 meg. of differences in 25,000 lines). The changes include a variety of large and small additions, ranging from the wholesale addition of a flash filesystem (YAFFS2), to very small patches to augment Linux security (paranoid networking patches).

Various efforts have been made over the past few years to submit these to changes to mainline (mostly by Google engineers, but also by others), with not much success so far.

Resources

A very good overview of the changes is available in a talk by John Stultz at ELC 2011. (The talk has a somewhat misleading name.)

• Android OS for Servers- John Stultz, ELC 2011
  • This talks breaks down the differences between an Android Linux kernel and a stock Linux kernel, and provides information about the features of each.
• http://www.lindusembedded.com/blog/2010/12/07/android-linux-kernel-additions/
  • Lindus Embedded (Alex Gonzalez) has a listing of kernel changes based on an Android kernel for the Freescale MX51 SOC, with some good information about each change.
• http://yidonghan.wordpress.com/2010/01/28/porting-android-to-a-new-device/
  • Peter McDermott’s excellent description of his work to port Android to the Nokia N810.
  • Also, see his annotated list of modified and added kernel files, at: http://www.linuxfordevices.com/files/misc/porting-android-to-a-new-device-p3.html
  • See the project site at sourceforge.
• http://www.slideshare.net/jollen/android-os-porting-introduction
  • Jollen Chen’s excellent presentation on system-level Android features, including an overview of kernel features unique to Android: Note: Parts of the presentation are in Chinese

Temporary including in mainline ‘staging’

Some changes were temporarily added at the «staging» driver area in the stock kernel, but were removed due to lack of support. See Greg KH blog post on -staging for 2.6.33, where he announces the removal of various Android drivers from -staging.

Android mainlining project

Several groups and individuals are working to get kernel changes from Android mainlined into the Linux kernel.

Please see Android Mainlining Project for more information.

List of kernel features unique to Android

Here is a list of changes/addons that the Android Project made to the linux kernel. As of September, 2011, these kernel changes are not part of the standard kernel and are only available in the Android kernel trees in the Android Open Source project.

This list does not include board- or platform-specific support or drivers (commonly called «board support»).

Binder

Binder is an Android-specific interprocess communication mechanism, and remote procedure call system similar to DBus.

ashmem

• ashmem — Android shared memory
  • implementation is in mm/ashmem.c

According to the Kconfig help «The ashmem subsystem is a new shared memory allocator, similar to POSIX SHM but with different behavior and sporting a simpler file-based API.»

Apparently it better-supports low memory devices, because it can discard shared memory units under memory pressure.

To use this, programs open /dev/ashmem, use mmap() on it, and can perform one or more of the following ioctls:

• ASHMEM_SET_NAME
• ASHMEM_GET_NAME
• ASHMEM_SET_SIZE
• ASHMEM_GET_SIZE
• ASHMEM_SET_PROT_MASK
• ASHMEM_GET_PROT_MASK
• ASHMEM_PIN
• ASHMEM_UNPIN
• ASHMEM_GET_PIN_STATUS
• ASHMEM_PURGE_ALL_CACHES

From a thread on android-platform source

You can create a shared memory segment using:

In the second process, instead of opening the region using the same name, for security reasons the file descriptor is passed to the other process via binder IPC.

The libcutils interface for ashmem consists of the following calls: (found in system/core/include/cutils/ashmem.h)

• int ashmem_create_region(const char *name, size_t size);
• int ashmem_set_prot_region(int fd, int prot);
• int ashmem_pin_region(int fd, size_t offset, size_t len);
• int ashmem_unpin_region(int fd, size_t offset, size_t len);
• int ashmem_get_size_region(int fd);

• PMEM — Process memory allocator
  • implementation at: drivers/misc/pmem.c with include file at: include/linux/android_pmem.h
  • Brian Swetland says:

David Sparks wrote the following: source

logger

• logger — system logging facility
  • This is the kernel support for the ‘logcat’ command
  • The kernel driver for the serial devices for logging are in the source code drivers/misc/logger.c
  • See Android logger for more information about the kernel code
  • See Android Logging System for an overview of the system it supports

wakelocks

• wakelock — used for power management files kernel/power/wakelock.c
  • Holds machine awake on a per-event basis until wakelock is released
  • See Android Power Management for detailed information

oom handling

• oom handling modifications
  • lowmem notifications
  • implementation at: drivers/misc/lowmemorykiller.c
  • also at: security/lowmem.c

Informally known as the Viking Killer, the OOM handler simply kills processes as available memory becomes low. The kernel module follows rules for this that are supplied from user space in two ways:

1. init writes information about memory levels and associated classes:

• The write value must be consistent with the above properties.
• Note that the driver only supports 6 slots, so we have combined some of the classes into the same memory level; the associated processes of higher classes will still be killed first.
  • From /init.rc:

2. User space sets the oom_adj of processes to put them in the correct class for their current operation. This redefines the meaning of oom_adj from that used by the standard OOM killer to something that is more aggressive and controlled.

These oom_adj levels end up being based on the process lifecycle defined here: http://developer.android.com/guide/topics/fundamentals.html#proclife

Alarm timers

This is the kernel implementation to support Android’s AlarmManager. It lets user space tell the kernel when it would like to wake up, allowing the kernel to schedule that appropriately and come back (holding a wake lock) when the time has expired regardless of the sleep state of the CPU.

POSIX Alarm Timers

Note that POSIX Alarm timers, which implement this functionality (but not identically), was accepted into mainline Linux in kernel version 3.0.

paranoid network security

• paranoid network security
  • See Android_Security#Paranoid_network-ing

timed output / timed gpio

Generic gpio is a mechanism to allow programs to access and manipulate gpio registers from user space.

Timed output/gpio is a system to allow chaning a gpio pin and restore it automatically after a specified timeout. See drives/misc/timed_output.c and drives/misc/timed_gpio.c This expose a user space interface used by the vibrator code.

On ADP1, there is a driver at:

Also, there is a device at:

RAM_CONSOLE

This allows saving the kernel printk messages to a buffer in RAM, so that after a kernel panic they can be viewed in the next kernel invocation, by accessing /proc/last_kmsg.

[Would be good to get more details on how to set this up and use it here!] [I guess this is something like pramfs?]

other kernel changes

Here is a miscellaneous list of other kernel changes in the mistral Android kernel:

Источник