In Linux kernel development, influence usually comes from solving problems reliably and earning trust—not from seeking visibility or sending patches directly to Linus Torvalds. The project routes changes through subsystem maintainers, whose review and integration decisions help move suitable work toward mainline.
How does influence work in the Linux kernel?
The kernel is organized into subsystems, and maintainers oversee particular areas of code. A maintainer may review a proposed change, accept it into a subsystem tree, or route selected changes onward through the development chain. That distributed process is why a contributor’s most useful relationships are often with the people and lists responsible for the code they are changing.
As an Amazon Associate I earn from qualifying purchases.
The development guide illustrates the point with a historical example from Linux 2.6.38: of more than 9,500 patches, 112—around 1.3%—were selected directly by Linus. Those figures describe that release-era example, not today’s patch volume; they show why the normal route is through subsystem maintainers rather than a direct submission to Linus. The kernel development-process guide explains the chain of trusted trees.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Who should I send a kernel patch to?
Identify the subsystem that owns the code, then follow its current submission guidance. Start with the repository’s MAINTAINERS file and use scripts/get_maintainer.pl to identify relevant maintainers and mailing lists. The right recipients and workflow depend on the code area; do not assume every subsystem uses the same base tree or review conventions.
#1 Best Overall
- Read the applicable subsystem profile and contribution instructions.
- Check which tree the subsystem expects your patch to be based on.
- Use the listed maintainers and mailing lists for the code you changed.
- Follow any subsystem-specific requirements for testing, formatting, or submission.
The patch-submission guide covers recipients, patch context, and reviewer responses. The maintainer handbooks and subsystem documentation can help locate local expectations. Sending directly to Linus is normally not the right path.
How do I get a kernel patch accepted?
Make the change straightforward to evaluate. Describe the problem in plain English, explain its effect for users or the system, and provide enough context for reviewers to understand why the change is appropriate. A patch is easier to assess when its rationale is clear rather than buried in implementation details.
- Understand the problem. Confirm the behavior or defect you are addressing and why a change is needed.
- Follow the subsystem’s route. Identify the maintainers, lists, expected base tree, and any local guidance before submitting.
- Explain the impact. In the submission, state the problem and user-visible effect plainly, then give the technical rationale.
- Engage with review. Make requested changes where appropriate. If you believe no code change is needed, explain why in a reply or changelog note so later reviewers can follow the reasoning.
- Keep the work moving. Track discussion and integration, and keep an unmerged patch current when follow-up is needed.
Acceptance is not guaranteed by a polished initial submission. Review can identify design, correctness, or integration concerns, and the maintainer responsible for the area decides whether the change belongs in that subsystem’s tree.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What happens after submission?
Kernel review is iterative and asynchronous. A change may move from design discussion to early review on relevant lists, then to wider review after a subsystem maintainer accepts it into a tree. Integration can expose additional issues. A small fix may move quickly; a large or controversial change can take much longer.
Rank #3
Maintainers often have other jobs, so silence does not by itself establish that a patch has been rejected. If a patch has no review objections but remains unmerged, the process guidance is to keep it current and persist with the review and merging process. Follow the subsystem’s norms for asking about status rather than assuming a fixed response time.
How do I respond to Linux kernel code review?
Treat review as technical collaboration, not a contest. Read comments carefully, answer the questions raised, and send revisions when they improve the change. If you disagree with a suggestion or do not think a code change is warranted, provide a reasoned explanation that addresses the concern. That gives the maintainer and subsequent reviewers a clear record of the decision.
Rank #4
- Used Book in Good Condition
- Address each substantive question rather than replying only with a new patch.
- Make the relationship between review feedback and code revisions clear.
- Explain unresolved disagreements with technical reasoning.
- Keep the patch and its rationale understandable as discussion continues.
What does maintainership require beyond technical judgment?
The kernel’s interpretation of its Code of Conduct defines a maintainer as someone responsible for a subsystem, driver, or file and listed in MAINTAINERS. It says maintainers should lead by example, while conduct responsibility remains shared across the community; maintainers are not expected to handle every behavior issue alone. They should help when problems arise and can seek assistance from the Technical Advisory Board (TAB) or other maintainers. The interpretation states, “First and foremost, it is a reasonable expectation to have maintainers lead by example.” Read the kernel’s Code of Conduct interpretation for the responsibilities described there.
The Linux Kernel Code of Conduct page reports 17 committee reports for the period April 1, 2024 through March 31, 2025. It describes development-process reports that included educating people about maintainers’ right to accept or reject patches and clarifying that developers cannot demand review or acceptance. The page also describes a 2025 documentation update clarifying enforcement and the TAB’s role. The count belongs to that specified reporting period; it is not an annual rate or a measure of current activity.
How do you grow from contributor to maintainer?
There is no documented shortcut or guaranteed timeline. The practical path is to build a record of useful work in a specific area, learn that subsystem’s review and integration practices, and collaborate dependably with the people who maintain it. As responsibility grows, the same habits that help a patch earn consideration—clear rationale, responsiveness, and respect for the review process—also help establish trust.
- Choose an area where you can understand the code and its users’ problems.
- Learn its maintainers, lists, documentation, and testing expectations.
- Submit focused work with a clear explanation of the problem and impact.
- Respond constructively to review and keep unresolved work current.
- Support collaborative conduct as well as technical quality.
Maintainership is a role tied to responsibility for code, not a prize for visibility. The current MAINTAINERS file and the relevant subsystem guidance are the authoritative places to check who is responsible and how that area works.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
