On Wednesday, August 25, 2021 12:38:02 PM CEST Dan Carpenter wrote:

On Wed, Aug 25, 2021 at 01:13:54PM +0300, Pavel Skripkin wrote:

quoted

On 8/25/21 1:06 PM, Dan Carpenter wrote:

quoted

On Wed, Aug 25, 2021 at 12:55:37PM +0300, Pavel Skripkin wrote:

quoted

The main problem, that no one knows who is the "old". Greg can take patches
in any order he wants

Patches are always taken in first come first serve.

OK, but if pending patch needs new version, then it will be taken at the
end?

Versions don't matter.  No one is tracking any of that.

A patch arrives.  It is either applied or rejected.  First come first
serve.

quoted

Here is the situation we have:

	I have the patch series based on old function behavior, it was
	posted first

	Then Fabio posted refactoring of the function and it changes
	return values.


Both series are pending right now and made on top of staging-next branch.
Who needs to rebase? I think, applying these series as-is can broke the
driver, since error handling will be broken

That's a bug then.  The patch should be rejected.  You're not allowed to
break the code.

Sorry Dan, I disagree. It's not a bug. No one intend to break the code. 
How could anyone know that someone else is working simultaneously on 
some code that is not compatible with the work of the other developer?

Pavel and I worked simultaneously on code based on the current Greg's tree.

We incidentally got to know that mine breaks his.

I suppose that Greg will take Pavel's work first, because it was submitted few 
hours before mine and then will ask me to take into account Pavel's patches, 
rebase, fix and resend mine.

Each series is self contained and does not introduce bugs to the current tree.
The bugs will arise when Greg will have applied one of the two series as usually 
in a FIFO order.

There's no practical means to know who is working to what just by reading all 
the messages of the lists. Who reads all the messages before deciding to work 
on something? This issue will be solved a way or the other, I really don't think it 
is a big problem, it's unavoidable when a lot of people work on the same 
driver or subsystem.

Regards,

Fabio  

Also don't write patches which lead to merge order breaking the code
silently.  That makes it difficult for stable as well.  For example,
don't do this:

-void frob(int a, int b);
+void frob(int b, int a);

In that case, you would change the name of the function so that the
build would break when people mix old and new code.

regards,
dan carpenter