Changes in Kconfig

315860c4f912990c75ef228775ea8871fc5bcc9a - binder: Fix up Kconfig dependancy due to removal of .c code

Thu, 17 Sep 2026 10:46:44 +0200

binder: Fix up Kconfig dependancy due to removal of .c codeWhen the .c binder code was removed, building the kernel if the rustbinder code was enabled, will cause the binder to not be built at all asthe option changed from .c to .rs which is probably not what theoriginal build wanted.Fix this up by renaming the option back to the _RUST version. If in thefuture, that suffix wants to be dropped, we can do so and then it willbe prompted for a choice again, but for this release cycle, it shouldstay as-is.Tested-by: Carlos Llamas Link: https://patch.msgid.link/2026091743-pony-prewar-735b@gregkhSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

fd2bc059ed466bdd95347a4f7891d150d94e7de2 - binder: rm -f binder.c

Sat, 12 Sep 2026 23:41:10 +0200

binder: rm -f binder.cThe day has finally come. We are dropping the legacy C implementationof the Binder IPC driver in favor of its Rust version.For 15+ years, the C driver has grown increasingly complex, making itincredibly painful to maintain and land new features without trippingover vulnerabilities. The Rust implementation alleviates most ofthese issues, so it's time for a change.Alice Ryhl has worked hard on the Rust binder for the past couple ofyears, not only achieving full feature parity but also proving that itcan match and often beat the performance of the C counterpart. Havingrun successfully on Android devices for some time now, we can no longercall this an "experiment".It's time to move on, yank the C code, and focus all new features andoptimizations on the Rust driver.Long live the new Rust Binder king!Cc: rust-for-linux@vger.kernel.orgAcked-by: Alice Ryhl Signed-off-by: Carlos Llamas Link: https://patch.msgid.link/rm-c-binder@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

f14e0c8183bc73c5ca0ad93670b5b74c71d86df2 - rust_binder: report netlink transactions

Tue, 07 Jul 2026 12:06:51 +0200

rust_binder: report netlink transactionsThe Android Binder driver supports a netlink API that reportstransaction *failures* to a userspace daemon. This allows devices tomonitor processes with many failed transactions so that it can e.g. killmisbehaving apps.One very important thing that this monitors is when many oneway messagesare sent to a frozen process, so there is special handling to ensurethis scenario is surfaced over netlink.Signed-off-by: Carlos Llamas Acked-by: Carlos Llamas Co-developed-by: Alice Ryhl Signed-off-by: Alice Ryhl Link: https://patch.msgid.link/20260707-binder-netlink-v7-3-42b40e4b1ac8@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

eafedbc7c050c44744fbdf80bdf3315e860b7513 - rust_binder: add Rust Binder driver

Fri, 19 Sep 2025 08:42:07 +0200

rust_binder: add Rust Binder driverWe're generally not proponents of rewrites (nasty uncomfortable thingsthat make you late for dinner!). So why rewrite Binder?Binder has been evolving over the past 15+ years to meet the evolvingneeds of Android. Its responsibilities, expectations, and complexityhave grown considerably during that time. While we expect Binder tocontinue to evolve along with Android, there are a number of factorsthat currently constrain our ability to develop/maintain it. Brieflythose are:1. Complexity: Binder is at the intersection of everything in Android and fulfills many responsibilities beyond IPC. It has become many things to many people, and due to its many features and their interactions with each other, its complexity is quite high. In just 6kLOC it must deliver transactions to the right threads. It must correctly parse and translate the contents of transactions, which can contain several objects of different types (e.g., pointers, fds) that can interact with each other. It controls the size of thread pools in userspace, and ensures that transactions are assigned to threads in ways that avoid deadlocks where the threadpool has run out of threads. It must track refcounts of objects that are shared by several processes by forwarding refcount changes between the processes correctly. It must handle numerous error scenarios and it combines/nests 13 different locks, 7 reference counters, and atomic variables. Finally, It must do all of this as fast and efficiently as possible. Minor performance regressions can cause a noticeably degraded user experience.2. Things to improve: Thousand-line functions [1], error-prone error handling [2], and confusing structure can occur as a code base grows organically. After more than a decade of development, this codebase could use an overhaul.[1]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/android/binder.c?h=v6.5#n2896[2]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/android/binder.c?h=v6.5#n36583. Security critical: Binder is a critical part of Android's sandboxing strategy. Even Android's most de-privileged sandboxes (e.g. the Chrome renderer, or SW Codec) have direct access to Binder. More than just about any other component, it's important that Binder provide robust security, and itself be robust against security vulnerabilities.It's #1 (high complexity) that has made continuing to evolve Binder andresolving #2 (tech debt) exceptionally difficult without causing #3(security issues). For Binder to continue to meet Android's needs, weneed better ways to manage (and reduce!) complexity without increasingthe risk.The biggest change is obviously the choice of programming language. Wedecided to use Rust because it directly addresses a number of thechallenges within Binder that we have faced during the last years. Itprevents mistakes with ref counting, locking, bounds checking, and alsodoes a lot to reduce the complexity of error handling. Additionally,we've been able to use the more expressive type system to encode theownership semantics of the various structs and pointers, which takes thecomplexity of managing object lifetimes out of the hands of theprogrammer, reducing the risk of use-after-frees and similar problems.Rust has many different pointer types that it uses to encode ownershipsemantics into the type system, and this is probably one of the mostimportant aspects of how it helps in Binder. The Binder driver has a lotof different objects that have complex ownership semantics; somepointers own a refcount, some pointers have exclusive ownership, andsome pointers just reference the object and it is kept alive in someother manner. With Rust, we can use a different pointer type for eachkind of pointer, which enables the compiler to enforce that theownership semantics are implemented correctly.Another useful feature is Rust's error handling. Rust allows for moresimplified error handling with features such as destructors, and you getcompilation failures if errors are not properly handled. This means thateven though Rust requires you to spend more lines of code than C onthings such as writing down invariants that are left implicit in C, theRust driver is still slightly smaller than C binder: Rust is 5.5kLOC andC is 5.8kLOC. (These numbers are excluding blank lines, comments,binderfs, and any debugging facilities in C that are not yet implementedin the Rust driver. The numbers include abstractions in rust/kernel/that are unlikely to be used by other drivers than Binder.)Although this rewrite completely rethinks how the code is structured andhow assumptions are enforced, we do not fundamentally change *how* thedriver does the things it does. A lot of careful thought has gone intothe existing design. The rewrite is aimed rather at improving codehealth, structure, readability, robustness, security, maintainabilityand extensibility. We also include more inline documentation, andimprove how assumptions in the code are enforced. Furthermore, allunsafe code is annotated with a SAFETY comment that explains why it iscorrect.We have left the binderfs filesystem component in C. Rewriting it inRust would be a large amount of work and requires a lot of bindings tothe file system interfaces. Binderfs has not historically had the samechallenges with security and complexity, so rewriting binderfs seems tohave lower value than the rest of Binder.Correctness and feature parity------------------------------Rust binder passes all tests that validate the correctness of Binder inthe Android Open Source Project. We can boot a device, and run a varietyof apps and functionality without issues. We have performed this both onthe Cuttlefish Android emulator device, and on a Pixel 6 Pro.As for feature parity, Rust binder currently implements all featuresthat C binder supports, with the exception of some debugging facilities.The missing debugging facilities will be added before we submit the Rustimplementation upstream.Tracepoints-----------I did not include all of the tracepoints as I felt that the mechansimfor making C access fields of Rust structs should be discussed on listseparately. I also did not include the support for building Rust Binderas a module since that requires exporting a bunch of additional symbolson the C side.Original RFC Link with old benchmark numbers: https://lore.kernel.org/r/20231101-rust-binder-v1-0-08ba9197f637@google.comCo-developed-by: Wedson Almeida Filho Signed-off-by: Wedson Almeida Filho Co-developed-by: Matt Gilbride Signed-off-by: Matt Gilbride Acked-by: Carlos Llamas Acked-by: Paul Moore Signed-off-by: Alice Ryhl Link: https://lore.kernel.org/r/20250919-rust-binder-v2-1-a384b09f28dd@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

63740349eba78f242bcbf60d5244d7f2b2600853 - binder: introduce transaction reports via netlink

Sun, 27 Jul 2025 20:29:06 +0200

binder: introduce transaction reports via netlinkIntroduce a generic netlink multicast event to report binder transactionfailures to userspace. This allows subscribers to monitor these eventsand take appropriate actions, such as stopping a misbehaving applicationthat is spamming a service with huge amount of transactions.The multicast event contains full details of the failed transactions,including the sender/target PIDs, payload size and specific error code.This interface is defined using a YAML spec, from which the UAPI andkernel headers and source are auto-generated.Signed-off-by: Li Li Signed-off-by: Carlos Llamas Link: https://lore.kernel.org/r/20250727182932.2499194-4-cmllamas@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

f6544dcdd0d2feb74f395072d8df52e3bea4be51 - binder: Convert binder_alloc selftests to KUnit

Mon, 14 Jul 2025 20:53:18 +0200

binder: Convert binder_alloc selftests to KUnitConvert the existing binder_alloc_selftest tests into KUnit tests. Thesetests allocate and free an exhaustive combination of buffers withvarious sizes and alignments. This change allows them to be run withoutblocking or otherwise interfering with other processes in binder.This test is refactored into more meaningful cases in the subsequentpatch.Signed-off-by: Tiffany Yang Acked-by: Carlos Llamas Link: https://lore.kernel.org/r/20250714185321.2417234-6-ynaffit@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

5e024582f494c6ff5eb2bec5183fd1eb35462500 - binder: Scaffolding for binder_alloc KUnit tests

Mon, 14 Jul 2025 20:53:17 +0200

binder: Scaffolding for binder_alloc KUnit testsAdd setup and teardown for testing binder allocator code with KUnit.Include minimal test cases to verify that tests are initializedcorrectly.Tested-by: Rae Moar Signed-off-by: Tiffany Yang Acked-by: Carlos Llamas Link: https://lore.kernel.org/r/20250714185321.2417234-5-ynaffit@google.comSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

1045a06724f322ed61f1ffb994427c7bdbe64647 - remove CONFIG_ANDROID

Wed, 29 Jun 2022 17:01:02 +0200

remove CONFIG_ANDROIDThe ANDROID config symbol is only used to guard the binder configsymbol and to inject completely random config changes. Remove itas it is obviously a bad idea.Acked-by: Paul E. McKenney Signed-off-by: Christoph Hellwig Link: https://lore.kernel.org/r/20220629150102.1582425-2-hch@lst.deSigned-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

a7f7f6248d9740d710fd6bd190293fe5e16410ac - treewide: replace '---help---' in Kconfig files with 'help'

Sat, 13 Jun 2020 18:50:22 +0200

treewide: replace '---help---' in Kconfig files with 'help'Since commit 84af7a6194e4 ("checkpatch: kconfig: prefer 'help' over'---help---'"), the number of '---help---' has been graduallydecreasing, but there are still more than 2400 instances.This commit finishes the conversion. While I touched the lines,I also fixed the indentation.There are a variety of indentation styles found. a) 4 spaces + '---help---' b) 7 spaces + '---help---' c) 8 spaces + '---help---' d) 1 space + 1 tab + '---help---' e) 1 tab + '---help---' (correct indentation) f) 1 tab + 1 space + '---help---' g) 1 tab + 2 spaces + '---help---'In order to convert all of them to 1 tab + 'help', I ran thefollowing commend: $ find . -name 'Kconfig*' | xargs sed -i 's/^[[:space:]]*---help---/\thelp/'Signed-off-by: Masahiro Yamada List of files: /linux/drivers/android/Kconfig

8ced0c6231ead26eca8cb416dcb7cc1c2cdd41d8 - binder: add functions to copy to/from binder buffers

Fri, 08 Feb 2019 19:35:15 +0100

binder: add functions to copy to/from binder buffersAvoid vm_area when copying to or from binder buffers.Instead, new copy functions are added that copy fromkernel space to binder buffer space. These usekmap_atomic() and kunmap_atomic() to create temporarymappings and then memcpy() is used to copy withinthat page.Also, kmap_atomic() / kunmap_atomic() use the appropriatecache flushing to support VIVT cache architectures.Allow binder to build if CPU_CACHE_VIVT is defined.Several uses of the new functions are added here. Moreto follow in subsequent patches.Signed-off-by: Todd Kjos Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

3ad20fe393b31025bebfc2d76964561f65df48aa - binder: implement binderfs

Fri, 14 Dec 2018 13:11:14 +0100

binder: implement binderfsAs discussed at Linux Plumbers Conference 2018 in Vancouver [1] this is theimplementation of binderfs./* Abstract */binderfs is a backwards-compatible filesystem for Android's binder ipcmechanism. Each ipc namespace will mount a new binderfs instance. Mountingbinderfs multiple times at different locations in the same ipc namespacewill not cause a new super block to be allocated and hence it will be thesame filesystem instance.Each new binderfs mount will have its own set of binder devices onlyvisible in the ipc namespace it has been mounted in. All devices in a newbinderfs mount will follow the scheme binder%d and numbering will alwaysstart at 0./* Backwards compatibility */Devices requested in the Kconfig via CONFIG_ANDROID_BINDER_DEVICES for theinitial ipc namespace will work as before. They will be registered viamisc_register() and appear in the devtmpfs mount. Specifically, thestandard devices binder, hwbinder, and vndbinder will all appear in theirstandard locations in /dev. Mounting or unmounting the binderfs mount inthe initial ipc namespace will have no effect on these devices, i.e. theywill neither show up in the binderfs mount nor will they disappear when thebinderfs mount is gone./* binder-control */Each new binderfs instance comes with a binder-control device. No otherdevices will be present at first. The binder-control device can be used todynamically allocate binder devices. All requests operate on the binderfsmount the binder-control device resides in.Assuming a new instance of binderfs has been mounted at /dev/binderfsvia mount -t binderfs binderfs /dev/binderfs. Then a request to create anew binder device can be made as illustrated in [2].Binderfs devices can simply be removed via unlink()./* Implementation details */- dynamic major number allocation: When binderfs is registered as a new filesystem it will dynamically allocate a new major number. The allocated major number will be returned in struct binderfs_device when a new binder device is allocated.- global minor number tracking: Minor are tracked in a global idr struct that is capped at BINDERFS_MAX_MINOR. The minor number tracker is protected by a global mutex. This is the only point of contention between binderfs mounts.- struct binderfs_info: Each binderfs super block has its own struct binderfs_info that tracks specific details about a binderfs instance: - ipc namespace - dentry of the binder-control device - root uid and root gid of the user namespace the binderfs instance was mounted in- mountable by user namespace root: binderfs can be mounted by user namespace root in a non-initial user namespace. The devices will be owned by user namespace root.- binderfs binder devices without misc infrastructure: New binder devices associated with a binderfs mount do not use the full misc_register() infrastructure. The misc_register() infrastructure can only create new devices in the host's devtmpfs mount. binderfs does however only make devices appear under its own mountpoint and thus allocates new character device nodes from the inode of the root dentry of the super block. This will have the side-effect that binderfs specific device nodes do not appear in sysfs. This behavior is similar to devpts allocated pts devices and has no effect on the functionality of the ipc mechanism itself.[1]: https://goo.gl/JL2tfX[2]: program to allocate a new binderfs binder device: #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include int main(int argc, char *argv[]) { int fd, ret, saved_errno; size_t len; struct binderfs_device device = { 0 }; if (argc < 2) exit(EXIT_FAILURE); len = strlen(argv[1]); if (len > BINDERFS_MAX_NAME) exit(EXIT_FAILURE); memcpy(device.name, argv[1], len); fd = open("/dev/binderfs/binder-control", O_RDONLY | O_CLOEXEC); if (fd < 0) { printf("%s - Failed to open binder-control device\n", strerror(errno)); exit(EXIT_FAILURE); } ret = ioctl(fd, BINDER_CTL_ADD, &device); saved_errno = errno; close(fd); errno = saved_errno; if (ret < 0) { printf("%s - Failed to allocate new binder device\n", strerror(errno)); exit(EXIT_FAILURE); } printf("Allocated new binder device with major %d, minor %d, and " "name %s\n", device.major, device.minor, device.name); exit(EXIT_SUCCESS); }Cc: Martijn Coenen Cc: Greg Kroah-Hartman Signed-off-by: Christian Brauner Acked-by: Todd Kjos Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

44d8047f1d87adc2fd7eccc88533794f6d88c15e - binder: use standard functions to allocate fds

Tue, 28 Aug 2018 22:46:25 +0200

binder: use standard functions to allocate fdsBinder uses internal fs interfaces to allocate and install fds:__alloc_fd__fd_install__close_fdget_files_structput_files_structThese were used to support the passing of fds between processesas part of a transaction. The actual allocation and installationof the fds in the target process was handled by the sendingprocess so the standard functions, alloc_fd() and fd_install()which assume task==current couldn't be used.This patch refactors this mechanism so that the fds areallocated and installed by the target process allowing thestandard functions to be used.The sender now creates a list of fd fixups that contains thestruct *file and the address to fixup with the new fd onceit is allocated. This list is processed by the target processwhen the transaction is dequeued.A new error case is introduced by this change. If an asynctransaction with file descriptors cannot allocate newfds in the target (probably due to out of file descriptors),the transaction is discarded with a log message. In the oldimplementation this would have been detected in the sendercontext and failed prior to sending.Signed-off-by: Todd Kjos Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

2e0e3a24ca50519219ebdd471e8b65043a10196b - android: binder: Drop dependency on !M68K

Wed, 06 Jun 2018 14:40:56 +0200

android: binder: Drop dependency on !M68KAs of commit 7124330dabe5b3cb ("m68k/uaccess: Revive 64-bitget_user()"), the 64-bit Android binder interface builds fine on m68k.Signed-off-by: Geert Uytterhoeven Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

1190b4e38f97023154e6b3bef61b251aa5f970d0 - ANDROID: binder: remove 32-bit binder interface.

Fri, 11 May 2018 10:45:24 +0200

ANDROID: binder: remove 32-bit binder interface.New devices launching with Android P need to use the 64-bitbinder interface, even on 32-bit SoCs [0].This change removes the Kconfig option to select the 32-bitbinder interface. We don't think this will affect existinguserspace for the following reasons:1) The latest Android common tree is 4.14, so we don't believe any Android devices are on kernels >4.14.2) Android devices launch on an LTS release and stick with it, so we wouldn't expect devices running on <= 4.14 now to upgrade to 4.17 or later. But even if they did, they'd rebuild the world (kernel + userspace) anyway.3) Other userspaces like 'anbox' are already using the 64-bit interface.Note that this change doesn't remove the 32-bit UAPIitself; the reason for that is that Android userspacealways uses the latest UAPI headers from upstream, anduserspace retains 32-bit support for devices that areupgrading. This will be removed as well in 2-3 years,at which point we can remove the code from the UAPIas well.Finally, this change introduces build errors on archs where64-bit get_user/put_user is not supported, so make binderunavailable on m68k (which wouldn't want it anyway).[0]: https://android-review.googlesource.com/c/platform/build/+/595193Signed-off-by: Martijn Coenen Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

b24413180f5600bcb3bb70fbed5cf186b60864bd - License cleanup: add SPDX GPL-2.0 license identifier to files with no license

Wed, 01 Nov 2017 15:07:57 +0100

License cleanup: add SPDX GPL-2.0 license identifier to files with no licenseMany source files in the tree are missing licensing information, whichmakes it harder for compliance tools to determine the correct license.By default all files without license information are under the defaultlicense of the kernel, which is GPL version 2.Update the files which contain no license information with the 'GPL-2.0'SPDX license identifier. The SPDX identifier is a legally bindingshorthand, which can be used instead of the full boiler plate text.This patch is based on work done by Thomas Gleixner and Kate Stewart andPhilippe Ombredanne.How this work was done:Patches were generated and checked against linux-4.14-rc6 for a subset ofthe use cases: - file had no licensing information it it. - file was a */uapi/* one with no licensing information in it, - file was a */uapi/* one with existing licensing information,Further patches will be generated in subsequent months to fix up caseswhere non-standard license headers were used, and references to licensehad to be inferred by heuristics based on keywords.The analysis to determine which SPDX License Identifier to be applied toa file was done in a spreadsheet of side by side results from of theoutput of two independent scanners (ScanCode & Windriver) producing SPDXtag:value files created by Philippe Ombredanne. Philippe prepared thebase worksheet, and did an initial spot review of a few 1000 files.The 4.13 kernel was the starting point of the analysis with 60,537 filesassessed. Kate Stewart did a file by file comparison of the scannerresults in the spreadsheet to determine which SPDX license identifier(s)to be applied to the file. She confirmed any determination that was notimmediately clear with lawyers working with the Linux Foundation.Criteria used to select files for SPDX license identifier tagging was: - Files considered eligible had to be source code files. - Make and config files were included as candidates if they contained >5 lines of source - File already had some variant of a license header in it (even if <5 lines).All documentation files were explicitly excluded.The following heuristics were used to determine which SPDX licenseidentifiers to apply. - when both scanners couldn't find any license traces, file was considered to have no license information in it, and the top level COPYING file license applied. For non */uapi/* files that summary was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 11139 and resulted in the first patch in this series. If that file was a */uapi/* path one, it was "GPL-2.0 WITH Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 WITH Linux-syscall-note 930 and resulted in the second patch in this series. - if a file had some form of licensing information in it, and was one of the */uapi/* ones, it was denoted with the Linux-syscall-note if any GPL family license was found in the file or had no licensing in it (per prior point). Results summary: SPDX license identifier # files ---------------------------------------------------|------ GPL-2.0 WITH Linux-syscall-note 270 GPL-2.0+ WITH Linux-syscall-note 169 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17 LGPL-2.1+ WITH Linux-syscall-note 15 GPL-1.0+ WITH Linux-syscall-note 14 ((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5 LGPL-2.0+ WITH Linux-syscall-note 4 LGPL-2.1 WITH Linux-syscall-note 3 ((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3 ((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1 and that resulted in the third patch in this series. - when the two scanners agreed on the detected license(s), that became the concluded license(s). - when there was disagreement between the two scanners (one detected a license but the other didn't, or they both detected different licenses) a manual inspection of the file occurred. - In most cases a manual inspection of the information in the file resulted in a clear resolution of the license that should apply (and which scanner probably needed to revisit its heuristics). - When it was not immediately clear, the license identifier was confirmed with lawyers working with the Linux Foundation. - If there was any question as to the appropriate license identifier, the file was flagged for further research and to be revisited later in time.In total, over 70 hours of logged manual review was done on thespreadsheet to determine the SPDX license identifiers to apply to thesource files by Kate, Philippe, Thomas and, in some cases, confirmationby lawyers working with the Linux Foundation.Kate also obtained a third independent scan of the 4.13 code base fromFOSSology, and compared selected files where the other two scannersdisagreed against that SPDX file, to see if there was new insights. TheWindriver scanner is based on an older version of FOSSology in part, sothey are related.Thomas did random spot checks in about 500 files from the spreadsheetsfor the uapi headers and agreed with SPDX license identifier in thefiles he inspected. For the non-uapi files Thomas did random spot checksin about 15000 files.In initial set of patches against 4.14-rc6, 3 files were found to havecopy/paste license identifier errors, and have been fixed to reflect thecorrect identifier.Additionally Philippe spent 10 hours this week doing a detailed manualinspection and review of the 12,461 patched files from the initial patchversion early this week with: - a full scancode scan run, collecting the matched texts, detected license ids and scores - reviewing anything where there was a license detected (about 500+ files) to ensure that the applied SPDX license was correct - reviewing anything where there was no detection but the patch license was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied SPDX license was correctThis produced a worksheet with 20 files needing minor correction. Thisworksheet was then exported into 3 different .csv files for thedifferent types of files to be modified.These .csv files were then reviewed by Greg. Thomas wrote a script toparse the csv files and add the proper SPDX tag to the file, in theformat that the file expected. This script was further refined by Gregbased on the output to detect more types of files automatically and todistinguish between header and source .c files (which need differentcomment types.) Finally Greg ran the script using the .csv files togenerate the patches.Reviewed-by: Kate Stewart Reviewed-by: Philippe Ombredanne Reviewed-by: Thomas Gleixner Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

4175e2b46fd4b9021ef81f18f1be9474b2f45d4a - android: binder: Add allocator selftest

Wed, 23 Aug 2017 17:46:40 +0200

android: binder: Add allocator selftestbinder_alloc_selftest tests that alloc_new_buf handles page allocation anddeallocation properly when allocate and free buffers. The test allocates 5buffers of various sizes to cover all possible page alignment cases, andfrees the buffers using a list of exhaustive freeing order.Test: boot the device with ANDROID_BINDER_IPC_SELFTEST config optionenabled. Allocator selftest passes.Signed-off-by: Sherry Yang Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

e8d2ed7db7c3cfbe92923c49cc5e830b0a0ee374 - Revert "staging: Fix build issues with new binder API"

Fri, 25 Aug 2017 02:39:51 +0200

Revert "staging: Fix build issues with new binder API"This reverts commit d0bdff0db809 ("staging: Fix build issues with newbinder API"), because commit e38361d032f1 ("ARM: 8091/2: add get_user()support for 8 byte types") has added the 64bit __get_user_asm_*implementation.Signed-off-by: Jisheng Zhang Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

9e18d0c82f0c07f2a41898d4adbb698a953403ee - ANDROID: binder: add hwbinder,vndbinder to BINDER_DEVICES.

Fri, 28 Jul 2017 13:56:07 +0200

ANDROID: binder: add hwbinder,vndbinder to BINDER_DEVICES.These will be required going forward.Signed-off-by: Martijn Coenen Cc: stable # 4.11+Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

dde04eb116fa1b0b0d443532af8c167520402b70 - binder: Add 'hwbinder' to the default devices

Wed, 15 Feb 2017 16:35:15 +0100

binder: Add 'hwbinder' to the default devicesAs AOSP master is now starting to require a hwbinder device, add it tothe the default Kconfig. Having the hwbinder device when not neededshouldn't hurt anything either.Cc: Greg Kroah-Hartman Cc: John Stultz Cc: Martijn Coenen Cc: Arve Hjønnevåg Cc: Amit Pundir Cc: Serban Constantinescu Cc: Dmitry Shmidt Cc: Rom Lemarchand Cc: Android Kernel Team Signed-off-by: Rob Herring Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig

ac4812c5ffbb88dd3280a6dacd39fcb73e077fe4 - binder: Support multiple /dev instances

Fri, 03 Feb 2017 23:40:48 +0100

binder: Support multiple /dev instancesAdd a new module parameter 'devices', that can beused to specify the names of the binder devicenodes we want to populate in /dev.Each device node has its own context manager, andis therefore logically separated from all the otherdevice nodes.The config option CONFIG_ANDROID_BINDER_DEVICES canbe used to set the default value of the parameter.This approach was favored over using IPC namespaces,mostly because we require a single process to be apart of multiple binder contexts, which seemed harderto achieve with namespaces.Cc: Greg Kroah-Hartman Cc: Martijn Coenen Cc: Arve Hjønnevåg Cc: Amit Pundir Cc: Serban Constantinescu Cc: Dmitry Shmidt Cc: Rom Lemarchand Cc: Android Kernel Team Signed-off-by: Martijn Coenen [jstultz: minor checkpatch warning fix]Signed-off-by: John Stultz Signed-off-by: Greg Kroah-Hartman List of files: /linux/drivers/android/Kconfig