This is why I moved to git. You can git stash each individual patch,
or easily maintain an independent branch separate from the rest, to
take your extra cognitive load to ZERO.
--------------------------------
Let me explain how to work together with git.
First, you clone the repo. This gives you the master branch.
Second, you create a personal branch, call it "emmanuel". Apply your
personal patches there. You no longer have to remember them or manage
them manually.
Third, you publish your repo in some Web server or gitorious repo or
something like that. I can give you access and space too, should you
want it.
Now you periodically pull from origin to get the latest and greatest.
You pull while being in master, your master branch gets merged. You
pull while being in emmanuel, your emmanuel branch gets merged.
Fourth, now you do some interesting work in ZFS that you think may be
useful for others (and, might I interject, you sure well know that we
all love and appreciate your work). To share it with us, just commit
that work in the master branch of your repo (or commit it to your
personal branch, then git cherry-pick that specific commit ID from
emmanuel into master), then push that master branch to the public repo
that you got ahold of. That is IT. Then, all I have to type is "git
pull emmanuel" and all your commits come in then get merged in, with
SHA1 sums and proper credit due to you. The next time you pull from
origin, git will KNOW that your commit went through to origin and
won't apply it doubly.
Fifth, you can use giggle to navigate your history locally, visually,
with a nice tree. It is invaluable.
Sixth, you can amend any of your commits as long as you haven't pushed
anything to your public repo. Git commit --amend.
Seventh, you can stack your personal patches in your emmanuel branch
atop anything that has been published in in my master repo. You can
see with giggle which commits are not yet in the master branch.
I have condensed TONS of git functionality here. I am also
volunteering to help you do ANYTHING that you want to do with git.
Just drop me a line.
> So I am thinking about just stopping to send patches, there is not much
> reason for me to continue to try to sync my tree with yours after all (which
> would be different if more people were sending patches). I might continue to
> improve the code on my side later though.
> Anyway here is a last patch to revert the put_nvlist modification.
> For some reason this allows zfs-fuse to work correctly when there is a
> problem in a raidz array. Apparently put_nvlist was really intended to fail
> in this case, the previous patch prevented it from failing and was creating
> an endless loop.
> Now the big surprise is that even when you revert to the previous state (by
> applying the attached patch), the disappearing pools bug doesn't come back !
> I don't have time to investigate why for now, sorry, but it could be a good
> way to test git after all, just try to remove a lot of patches until the bug
> comes back and you'll have your culprit.
> So anyway even without the culprit the best option for now it to revert
> put_nvlist to what it was before by applying this patch.
This is precisely why we need git. For example, at the moment I have
no idea on what patch this patch depends, so I can't apply it. With
git, all you'd have to do is git push, and I would have to git pull,
and presto, it's done.
Word to the wise: stop juggling patches by hand. There is a reason
why the kernel developers use git.