Stop maintainer abuse
cover Stop maintainer abuse
This patch series amends the kernel development process to reduce the load on key maintainers during peak periods, by discouraging the submission of non-urgent patches while the merge window is open.
Original discussion here:
https://lkml.org/lkml/2014/12/12/772
(As a non-subsystem-maintainer I don't really have a horse in this race, but if everyone else agrees that it's the right thing to do, we might as well make it the official policy and start teaching it to new developers.)
Kevin Cernekee (4):
Documentation: Change policy on sending patches during merge window Documentation/SubmitChecklist: Remind submitters to check the merge
window
Documentation: Add cutoff periods for patch acceptance
Documentation: Provide suggestions on when to repost patches
Documentation/SubmitChecklist | 5 +++++ Documentation/development-process/5.Posting | 25 +++++++++++++++++++++++ Documentation/development-process/6.Followthrough | 5 ++++- 3 files changed, 34 insertions(+), 1 deletion(-)
Signature · 1 line
2.1.1
RFC 1/4 Documentation: Change policy on sending patches during merge window
Ask patch submitters to avoid sending non-critical patches when the merge window is open. This basically extends the net-next policy in netdev-FAQ.txt to the entire kernel.
--- Documentation/development-process/5.Posting | 9 +++++++++ 1 file changed, 9 insertions(+)
Documentation/development-process/5.Posting +9 -0
@@ -26,6 +26,15 @@ which remains to be done and any known problems. Fewer people will look at patches which are known to be half-baked, but those who do will come in with the idea that they can help you drive the work in the right direction. +Some maintainers prefer to receive only urgent patches when the merge +window is open, so that critical fixes do not get lost in the noise during +times of peak activity. If you are posting an actual [PATCH] (not something +that is obviously low-priority such as an [RFC] or [RANT]) and you aren't sure +of your maintainer's stance, the safest thing to do is hold off until the +merge window has closed. You can visit https://www.kernel.org/ to check +the merge window status; it is closed if the "mainline:" entry shows a +version number containing "-rc", and open if a non-rc version number appears. + 5.2: BEFORE CREATING PATCHES
Signature · 1 line
2.1.1
Re: [RFC 1/4] Documentation: Change policy on sending patches during merge window
Quoted 3 lines · Kevin Cernekee
Ask patch submitters to avoid sending non-critical patches when the merge window is open. This basically extends the net-next policy in netdev-FAQ.txt to the entire kernel.
FYI, I very mich disagree with that. Merge window isn't really special, and patches can easily be reviewed and queued up for the next merge window in that time. If it said you shouldn't expect replies and not _resend_ during the merge window that seems like a much saner policy.
RFC 2/4 Documentation/SubmitChecklist: Remind submitters to check the merge window
In reply to Kevin CernekeeCurrently the checklist does not provide an indication of appropriate times to send patches; add a brief note on the topic.
--- Documentation/SubmitChecklist | 5 +++++ 1 file changed, 5 insertions(+)
Documentation/SubmitChecklist +5 -0
@@ -107,3 +107,8 @@ kernel patches. CONFIG_SMP, CONFIG_SYSFS, CONFIG_PROC_FS, CONFIG_INPUT, CONFIG_PCI, CONFIG_BLOCK, CONFIG_PM, CONFIG_MAGIC_SYSRQ, CONFIG_NET, CONFIG_INET=n (but latter with CONFIG_NET=y) + +27: For patches which are not urgent fixes for bugs in the current tree, + double-check https://www.kernel.org/ to make sure the merge window is + CLOSED ("mainline:" showing an -rc kernel) before sending. For more + information on the release cycle, see Documentation/development-process/.
Signature · 1 line
2.1.1
Re: [RFC 2/4] Documentation/SubmitChecklist: Remind submitters to check the merge window
Quoted 13 lines · Kevin Cernekee
Currently the checklist does not provide an indication of appropriate times to send patches; add a brief note on the topic.
Signed-off-by Kevin Cernekee <[email protected]>--- Documentation/SubmitChecklist | 5 +++++ 1 file changed, 5 insertions(+)Documentation/SubmitChecklist +0
-0
Documentation/SubmitChecklist kernel patches. · line 114
Quoted 8 lines
Documentation/SubmitChecklist +5
-0@@ -107,3 +107,8 @@ kernel patches. CONFIG_SMP, CONFIG_SYSFS, CONFIG_PROC_FS, CONFIG_INPUT, CONFIG_PCI, CONFIG_BLOCK, CONFIG_PM, CONFIG_MAGIC_SYSRQ, CONFIG_NET, CONFIG_INET=n (but latter with CONFIG_NET=y) + +27: For patches which are not urgent fixes for bugs in the current tree, + double-check https://www.kernel.org/ to make sure the merge window is + CLOSED ("mainline:" showing an -rc kernel) before sending. For more + information on the release cycle, see Documentation/development-process/.
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Re: [RFC 2/4] Documentation/SubmitChecklist: Remind submitters to check the merge window
In reply to Kevin CernekeeDocumentation/SubmitChecklist kernel patches. · line 114
Quoted 4 lines · Kevin Cernekee
+27: For patches which are not urgent fixes for bugs in the current tree,
Documentation/SubmitChecklist +3
-0+ double-check https://www.kernel.org/ to make sure the merge window is + CLOSED ("mainline:" showing an -rc kernel) before sending. For more + information on the release cycle, see Documentation/development-process/.
Maybe the crystal ball should be extended to show if the merge is open or closed? And if it's closed, an estimate when the next merge window starts would be nice ("Merge window is closed, estimate for it to open:
21 days").
I'm sure Johannes would be happy to take patches.
Signature · 1 line
Kalle Valo
RFC 3/4 Documentation: Add cutoff periods for patch acceptance
In reply to Kevin CernekeeThis has been a recurring source of confusion for the new submitters who I've helped; let's see if adding a small illustration improves the situation.
--- Documentation/development-process/5.Posting | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
Documentation/development-process/5.Posting +16 -0
@@ -35,6 +35,22 @@ merge window has closed. You can visit https://www.kernel.org/ to check the merge window status; it is closed if the "mainline:" entry shows a version number containing "-rc", and open if a non-rc version number appears. +In many cases, feature additions received and accepted somewhere in the range +of [N-rc1, N-rc5) will be merged into the -next tree targeting the (N+1) Linux +release. For example: + + kernel.org "mainline:" | Patch may appear + field when posted | in released kernel + ------------------------+-------------------------------- + 3.18-rc[1-4] | 3.19 + 3.18-rc[5-9] | 3.20 + 3.18 | Merge window open - don't post + 3.19-rc[1-4] | 3.20 + 3.19-rc[5-9] | 3.21 + 3.19 | Merge window open - don't post + +Bug fixes can typically be accepted at any time. + 5.2: BEFORE CREATING PATCHES
Signature · 1 line
2.1.1
Re: [RFC 3/4] Documentation: Add cutoff periods for patch acceptance
Quoted 22 lines · Kevin Cernekee
This has been a recurring source of confusion for the new submitters who I've helped; let's see if adding a small illustration improves the situation.
Signed-off-by Kevin Cernekee <[email protected]>--- Documentation/development-process/5.Posting | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)Documentation/development-process/5.Posting +5
-0@@ -35,6 +35,22 @@ merge window has closed. You can visit https://www.kernel.org/ to check the merge window status; it is closed if the "mainline:" entry shows a version number containing "-rc", and open if a non-rc version number appears. +In many cases, feature additions received and accepted somewhere in the range +of [N-rc1, N-rc5) will be merged into the -next tree targeting the (N+1) Linux +release. For example: + + kernel.org "mainline:" | Patch may appear
Documentation/development-process/5.Posting merge window has closed. You can visit https://www.kernel.org/ to check · line 52
Quoted 10 lines
Documentation/development-process/5.Posting +10
-0+ field when posted | in released kernel + ------------------------+-------------------------------- + 3.18-rc[1-4] | 3.19 + 3.18-rc[5-9] | 3.20 + 3.18 | Merge window open - don't post + 3.19-rc[1-4] | 3.20 + 3.19-rc[5-9] | 3.21 + 3.19 | Merge window open - don't post + +Bug fixes can typically be accepted at any time.
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Re: [RFC 3/4] Documentation: Add cutoff periods for patch acceptance
In reply to Kevin CernekeeDocumentation/development-process/5.Posting merge window has closed. You can visit https://www.kernel.org/ to check · line 52
Quoted 12 lines
Documentation/development-process/5.Posting +12
-0+ + kernel.org "mainline:" | Patch may appear + field when posted | in released kernel + ------------------------+-------------------------------- + 3.18-rc[1-4] | 3.19 + 3.18-rc[5-9] | 3.20 + 3.18 | Merge window open - don't post + 3.19-rc[1-4] | 3.20 + 3.19-rc[5-9] | 3.21 + 3.19 | Merge window open - don't post + +Bug fixes can typically be accepted at any time.
That's exactly what was needed I think
Re: [RFC 3/4] Documentation: Add cutoff periods for patch acceptance
Quoted 6 lines · One Thousand Gnomes
Quoted 6 lines
Documentation/development-process/5.Posting +6
-0+ + kernel.org "mainline:" | Patch may appear + field when posted | in released kernel + ------------------------+-------------------------------- + 3.18-rc[1-4] | 3.19 + 3.18-rc[5-9] | 3.20
Quoted 8 lines
Documentation/development-process/5.Posting merge window has closed. You can visit https://www.kernel.org/ to check · line 52
Quoted 6 lines
Documentation/development-process/5.Posting +6
-0+ 3.18 | Merge window open - don't post + 3.19-rc[1-4] | 3.20 + 3.19-rc[5-9] | 3.21 + 3.19 | Merge window open - don't post + +Bug fixes can typically be accepted at any time.That's exactly what was needed I think
So I don't think this is wrong per se, but I do think that it should also have a clarification that
(a) the above "may appear" is basically "best possible timings", and
things can get delayed by various issues
(b) the exact timing is maintainer-specific.
For that (b) in particular, for fairly simple subsystems in particular, some maintainers basically have their pull requests for the merge window open *before* the merge window even starts, and for them, the merge window itself isn't actually all that busy, it's often the week before that is the busy one. So the exact timing can vary by maintainership, and while I think the above is a reasonable example, it should perhaps be documented as such. An *example*, not a "this is how it always works". If you are preparing a 50-patch monster, I suspect you may want to talk to the maintainer you're planning on spamming before you send it out.
Linus
RFC 4/4 Documentation: Provide suggestions on when to repost patches
In reply to Kevin CernekeeGive submitters a rough idea of how long to wait before reposting, to help avoid situations where a series is reposted before the original submission is fully reviewed.
--- Documentation/development-process/6.Followthrough | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
Documentation/development-process/6.Followthrough +4 -1
@@ -74,7 +74,10 @@ around. One fatal mistake is to ignore review comments in the hope that they will go away. They will not go away. If you repost code without having responded to the comments you got the time before, you're likely to find -that your patches go nowhere. +that your patches go nowhere. On the flipside, reposting an updated patch +before the original has been fully reviewed can be a source of frustration +too, so consider giving the reviewers ~3-7 calendar days (depending on +patch complexity) before posting V2. Speaking of reposting code: please bear in mind that reviewers are not going to remember all the details of the code you posted the last time
Signature · 1 line
2.1.1
Re: [RFC 4/4] Documentation: Provide suggestions on when to repost patches
Quoted 15 lines · Kevin Cernekee
Give submitters a rough idea of how long to wait before reposting, to help avoid situations where a series is reposted before the original submission is fully reviewed.
Suggested-by Thomas Gleixner <[email protected]>Signed-off-by Kevin Cernekee <[email protected]>--- Documentation/development-process/6.Followthrough | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)Documentation/development-process/6.Followthrough +0
-0
Documentation/development-process/6.Followthrough around. · line 79
Quoted 7 lines
Documentation/development-process/6.Followthrough +3
-1@@ -74,7 +74,10 @@ around. One fatal mistake is to ignore review comments in the hope that they will go away. They will not go away. If you repost code without having responded to the comments you got the time before, you're likely to find -that your patches go nowhere. +that your patches go nowhere. On the flipside, reposting an updated patch +before the original has been fully reviewed can be a source of frustration +too,
I'd like to make that aspect stronger/more explicit:
"Please do repost only after the reviewers have finished going through your submission and you have collected, addressed and/or incorporated their full feedback. You can use the time while waiting to test and hammer more on your code. Any non-trivial submission of a patchset should be resent after a full week (7 days) the earliest in order not to spam people unnecessarily and to give them a chance to at least finish reviewing."
Anyway, something like that, formulation might need more cleaning up - I was just trying to express the sentiment...
Quoted 5 lines
so consider giving the reviewers ~3-7 calendar days (depending on +patch complexity) before posting V2.
Speaking of reposting code: please bear in mind that reviewers are not going to remember all the details of the code you posted the last time
Thanks for doing this, btw!
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Jonathan Corbet
maintainerQuoted 3 lines · On Sun, 14 Dec 2014 22:09:46 -0800 Kevin Cernekee <[email protected]> wrote:
This patch series amends the kernel development process to reduce the load on key maintainers during peak periods, by discouraging the submission of non-urgent patches while the merge window is open.
You do understand the irony of posting this during the merge window, right? :)
In general, I worry about trying to codify things too much just because different maintainers have different expectations. As Linus noted, some maintainers have their work done by the time the merge window starts and can take patches just fine — until something catches fire, at least.
I'll await a revision taking account the feedback you've gotten, just adding my own suggestion to phrase things as guidelines rather than hard-and-fast rules.
Thanks,
jon
Quoted 5 lines · Jonathan Corbet
In general, I worry about trying to codify things too much just because different maintainers have different expectations. As Linus noted, some maintainers have their work done by the time the merge window starts and can take patches just fine — until something catches fire, at least.
Yeah, I think it's going to be really different pretty much all maintainers.
Speaking for myself, that's what patchwork is for. There are plenty of other times besides merge window when I'm going to be super busy --- say, because I'm travelling to a conference or for business reasons. And those times are far more likely to be hard on me as a maintainer compared to the merge window. So everyone's mileage going to vary widely.
And having a strict schedule like this:
+ kernel.org "mainline:" | Patch may appear + field when posted | in released kernel + ------------------------+-------------------------------- + 3.18-rc[1-4] | 3.19 + 3.18-rc[5-9] | 3.20 + 3.18 | Merge window open - don't post + 3.19-rc[1-4] | 3.20 + 3.19-rc[5-9] | 3.21 + 3.19 | Merge window open - don't post
+
+Bug fixes can typically be accepted at any time.
Seems like it's very, VERY bad ju-ju. I'll take some feature patches as late as -rc6, if they are simple and I'm confident that regression testing will catch any problems (because for file systems, very often xfstests is far more likely to find problems than soak time in linux-next).
On the flip side, a feature patch, submitted between -rc2 and -rc3, might not make it because we want more people to look at it, better benchmarks, etc., etc. Even a bug fix submitted at that point might not make it, especially if the bug is extremely rare (and we may have lived with it for years or decades), and the change is especially risky/hairy.
So having a schedule like this is very likely going to set all sorts of false expectations, and may end up causing just as many problems as it purports to solve.
I wonder if this sort of thing is better placed in various unofficial documentations which help new users acculturate. For example, see some of the slides in the last half of Sarah Sharp's presentation here:
https://plus.google.com/+SarahSharp/posts/4GSqqGpg8cg
That has the advantage of significantly reducing the risk that things that originally started out as preferences by a few maintainers getting turned into bureaucratic rules.
- Ted
Quoted 9 lines · Jonathan Corbet
Quoted 3 lines · On Sun, 14 Dec 2014 22:09:46 -0800 Kevin Cernekee <[email protected]> wrote:
This patch series amends the kernel development process to reduce the load on key maintainers during peak periods, by discouraging the submission of non-urgent patches while the merge window is open.
You do understand the irony of posting this during the merge window, right? :)
I specifically exempted [RFC] from the rules because these threads are readily distinguishable from urgent patches. One could envision setting up a procmail rule to move all [RFC] and [.*-next] messages into a "save for later" folder.
Quoted 4 lines
In general, I worry about trying to codify things too much just because different maintainers have different expectations. As Linus noted, some maintainers have their work done by the time the merge window starts and can take patches just fine — until something catches fire, at least.
Do you think it might make sense to list the (stricter?) patch acceptance policies in MAINTAINERS?
In the current process, many submitters do not know their maintainer's policy until they get in trouble for violating it. This is not a very efficient way of educating people. It might work if a submitter is focusing most of his efforts on a small number of subsystems, with which he becomes familiar over time. But it doesn't work if somebody has to touch many different areas of the kernel just once to e.g. add support for a new SoC (including its syscon devices, irqchip drivers, regulators, clocks, buses, and peripherals).
Quoted 2 lines · Kevin Cernekee
In the current process, many submitters do not know their maintainer's policy until they get in trouble for violating it.
Just say what Christoph suggested: people should not expect any feedback during the merge window. If they get some, fine. It can't get any simpler than that.
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Quoted 7 lines · Borislav Petkov
Quoted 2 lines · Kevin Cernekee
In the current process, many submitters do not know their maintainer's policy until they get in trouble for violating it.
Just say what Christoph suggested: people should not expect any feedback during the merge window. If they get some, fine. It can't get any simpler than that.
Or during the week of Plumber's Conference... or LSF/MM... or the during the Kernel Summit... or if they are in transit to Linux.conf.au.... sometimes a patch submitter won't get feedback right away. It's nothing personal.
With all due respect to Steven, I think he over-reacted a little with his "maintainer abuse" reply. Most of the time people won't get "yelled" at if they send patches at the wrong time. And what's wrong for one maintainer will be right for another, and vice versa.
- Ted
Quoted 2 lines · Theodore Ts'o
And what's wrong for one maintainer will be right for another, and
vice versa.
Ok, so what's wrong with "should not expect any feedback during the merge window"?
If they get it, then that's fine. The formulation is loose on purpose.
And besides, when one starts working with maintainers, one soon learns when they are the busiest and can refrain from sending patchsets then.
Or should we have subsystem maintainers each state whether they wanna do patchsets during the merge window or not? Or are we bikeshedding already?
I see your point that different maintainers can be busy at different times but you also have to acknowledge the desire of some maintainers not to get new patchsets during the merge window. So we have to have a way to communicate that to submitters so that no explosions happen.
Oh, and also the not-resend-in-under-a-week-and-wait-out-complete-review-first rule. That's my personal pet peeve.
Ha, this sounds like a KS topic :-P
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Quoted 7 lines · Borislav Petkov
Quoted 2 lines · Theodore Ts'o
And what's wrong for one maintainer will be right for another, and
vice versa.Ok, so what's wrong with "should not expect any feedback during the merge window"?
AFAICT the original complaint wasn't about people expecting feedback during the merge window, it was about people sending things at all which is a different thing.
Quoted 2 lines
And besides, when one starts working with maintainers, one soon learns when they are the busiest and can refrain from sending patchsets then.
Or if that even makes a difference of course.
Quoted 4 lines
I see your point that different maintainers can be busy at different times but you also have to acknowledge the desire of some maintainers not to get new patchsets during the merge window. So we have to have a way to communicate that to submitters so that no explosions happen.
I think it's important to be clear what we're talking about when we advise people; the advice about allowing for people being busy or otherwise unavailable applies pretty much all the time - one of the most common process problems I see is people expecting quick turnaround times, it'd be really good to set expecations there and it seems hard to go wrong.
Not posting at all is a bit different, though, and is much more maintainer specific - personally I'm in the opposite camp to Thomas and would rather people just sent things whenever so I can get round to them as I have time rather than getting everyone sending things at once.
Quoted 4 lines · Jonathan Corbet
In general, I worry about trying to codify things too much just because different maintainers have different expectations. As Linus noted, some maintainers have their work done by the time the merge window starts and can take patches just fine — until something catches fire, at least.
As one of the recipients of the original evidence ("[v3 00/26] Add VT-d Posted-Interrupts support"), I can only agree.
The timing of the series wasn't optimal for me, either: I do _not_ take patches during the merge window and generally would like people that are not KVM submaintainers to leave me alone.
On the other hand, the series is complex and spans four maintainers (KVM, VFIO, IOMMU, x86), and it would be weird to blame people for posting early. In this case the x86 parts are just one patch out of 26.
When x86 maintainers see something like this, they can expect the KVM
maintainer (me) to tell them "can you review the approach" or just "can you give your Acked-by" once the rest of the series is mature.
As an example of a different workflow, generally things go like this for me:
window Put up fires, otherwise do non-kernel stuff
rc1-rc2 Test large features, gather small patches in a rebased queue
rc2-rc3 Big testing week: open next tree
rc3-rc6 Merge small features
rc6- Merge bugfixes only, do non-kernel stuff, start bugging
submaintainers
So for me the worst time to send patches is actually the week between rc2 and rc3. You're pretty much guaranteed to be ignored at that time, unless of course the patch is for current mainline.
If you send during the merge window, chances are I'll be busy doing something else and I won't have a fast turnaround. But a mail from your manager asking to merge a large feature after rc6 will definitely make me more grumpy.
Paolo
Quoted 2 lines · Paolo Bonzini
But a mail from your manager asking to merge a large feature after rc6 will definitely make me more grumpy.
I sincerely hope it'll never be the case where managers dictate the development on lkml. If this happens, we're terminally screwed.
Signature · 5 lines
Regards/Gruss,
Boris.
Sent from a fat crate under my desk. Formatting is fine.
--Quoted 5 lines · Borislav Petkov
Quoted 2 lines
But a mail from your manager asking to merge a large feature after rc6 will definitely make me more grumpy.
I sincerely hope it'll never be the case where managers dictate the development on lkml. If this happens, we're terminally screwed.
They don't; they just try. :)
paolo