In early 2003, Andreas Gruenbacher and Martin Quinson borrowed the approach of Andrew's scripts and published a tool called “patchwork quilt” [web:quilt], or simply “quilt” (see [gruenbacher:2005] for a paper describing it). Because quilt substantially automated patch management, it rapidly gained a large following among open source software developers.

Quilt manages a stack of patches on top of a directory tree. To begin, you tell quilt to manage a directory tree, and tell it which files you want to manage; it stores away the names and contents of those files. To fix a bug, you create a new patch (using a single command), edit the files you need to fix, then “refresh” the patch.

The refresh step causes quilt to scan the directory tree; it updates the patch with all of the changes you have made. You can create another patch on top of the first, which will track the changes required to modify the tree from “tree with one patch applied” to “tree with two patches applied”.

You can change which patches are applied to the tree. If you “pop” a patch, the changes made by that patch will vanish from the directory tree. Quilt remembers which patches you have popped, though, so you can “push” a popped patch again, and the directory tree will be restored to contain the modifications in the patch. Most importantly, you can run the “refresh” command at any time, and the topmost applied patch will be updated. This means that you can, at any time, change both which patches are applied and what modifications those patches make.

Quilt knows nothing about revision control tools, so it works equally well on top of an unpacked tarball or a Subversion working copy.

In mid-2005, Chris Mason took the features of quilt and wrote an extension that he called Mercurial Queues, which added quilt-like behavior to Mercurial.

The key difference between quilt and MQ is that quilt knows nothing about revision control systems, while MQ is integrated into Mercurial. Each patch that you push is represented as a Mercurial changeset. Pop a patch, and the changeset goes away.

Because quilt does not care about revision control tools, it is still a tremendously useful piece of software to know about for situations where you cannot use Mercurial and MQ.

To begin work on a new patch, use the qnew command. This command takes one argument, the name of the patch to create.

MQ will use this as the name of an actual file in the .hg/patches directory, as you can see below.

$ hg tip
changeset:   0:ba8df3126338
tag:         tip
user:        Bryan O'Sullivan <[email protected]>
date:        Tue May 05 06:55:41 2009 +0000
summary:     first change

$ hg qnew first.patch
$ hg tip
changeset:   1:0eef7631d242
tag:         qtip
tag:         first.patch
tag:         tip
tag:         qbase
user:        Bryan O'Sullivan <[email protected]>
date:        Tue May 05 06:55:41 2009 +0000
summary:     [mq]: first.patch

$ ls .hg/patches
first.patch  series  status

Also newly present in the .hg/patches directory are two other files, series and status. The series file lists all of the patches that MQ knows about for this repository, with one patch per line. Mercurial uses the status file for internal book-keeping; it tracks all of the patches that MQ has applied in this repository.

	Note
	You may sometimes want to edit the series file by hand; for example, to change the sequence in which some patches are applied. However, manually editing the status file is almost always a bad idea, as it's easy to corrupt MQ's idea of what is happening.

Once you have created your new patch, you can edit files in the working directory as you usually would. All of the normal Mercurial commands, such as hg diff and hg annotate, work exactly as they did before.

When you reach a point where you want to save your work, use the qrefresh command to update the patch you are working on.

$ echo 'line 2' >> file1
$ hg diff
diff -r 0eef7631d242 file1
--- a/file1	Tue May 05 06:55:41 2009 +0000
+++ b/file1	Tue May 05 06:55:41 2009 +0000
@@ -1,1 +1,2 @@
 line 1
+line 2
$ hg qrefresh
$ hg diff
$ hg tip --style=compact --patch
1[qtip,first.patch,tip,qbase]   b737e7b1c206   2009-05-05 06:55 +0000   bos
  [mq]: first.patch

diff -r ba8df3126338 -r b737e7b1c206 file1
--- a/file1	Tue May 05 06:55:41 2009 +0000
+++ b/file1	Tue May 05 06:55:41 2009 +0000
@@ -1,1 +1,2 @@
 line 1
+line 2

This command folds the changes you have made in the working directory into your patch, and updates its corresponding changeset to contain those changes.

You can run qrefresh as often as you like, so it's a good way to “checkpoint” your work. Refresh your patch at an opportune time; try an experiment; and if the experiment doesn't work out, hg revert your modifications back to the last time you refreshed.

$ echo 'line 3' >> file1
$ hg status
M file1
$ hg qrefresh
$ hg tip --style=compact --patch
1[qtip,first.patch,tip,qbase]   a2efdba241e8   2009-05-05 06:55 +0000   bos
  [mq]: first.patch

diff -r ba8df3126338 -r a2efdba241e8 file1
--- a/file1	Tue May 05 06:55:41 2009 +0000
+++ b/file1	Tue May 05 06:55:42 2009 +0000
@@ -1,1 +1,3 @@
 line 1
+line 2
+line 3

Once you have finished working on a patch, or need to work on another, you can use the qnew command again to create a new patch. Mercurial will apply this patch on top of your existing patch.

$ hg qnew second.patch
$ hg log --style=compact --limit=2
2[qtip,second.patch,tip]   4bb84cd8876a   2009-05-05 06:55 +0000   bos
  [mq]: second.patch

1[first.patch,qbase]   a2efdba241e8   2009-05-05 06:55 +0000   bos
  [mq]: first.patch

$ echo 'line 4' >> file1
$ hg qrefresh
$ hg tip --style=compact --patch
2[qtip,second.patch,tip]   8287e9f12f96   2009-05-05 06:55 +0000   bos
  [mq]: second.patch

diff -r a2efdba241e8 -r 8287e9f12f96 file1
--- a/file1	Tue May 05 06:55:42 2009 +0000
+++ b/file1	Tue May 05 06:55:42 2009 +0000
@@ -1,3 +1,4 @@
 line 1
 line 2
 line 3
+line 4

$ hg annotate file1
0: line 1
1: line 2
1: line 3
2: line 4

Notice that the patch contains the changes in our prior patch as part of its context (you can see this more clearly in the output of hg annotate).

So far, with the exception of qnew and qrefresh, we've been careful to only use regular Mercurial commands. However, MQ provides many commands that are easier to use when you are thinking about patches, as illustrated below.

$ hg qseries
first.patch
second.patch
$ hg qapplied
first.patch
second.patch

The previous discussion implied that there must be a difference between “known” and “applied” patches, and there is. MQ can manage a patch without it being applied in the repository.

An applied patch has a corresponding changeset in the repository, and the effects of the patch and changeset are visible in the working directory. You can undo the application of a patch using the qpop command. MQ still knows about, or manages, a popped patch, but the patch no longer has a corresponding changeset in the repository, and the working directory does not contain the changes made by the patch. Figure 12.1, “Applied and unapplied patches in the MQ patch stack” illustrates the difference between applied and tracked patches.

Figure 12.1. Applied and unapplied patches in the MQ patch stack

You can reapply an unapplied, or popped, patch using the qpush command. This creates a new changeset to correspond to the patch, and the patch's changes once again become present in the working directory. See below for examples of qpop and qpush in action.

$ hg qapplied
first.patch
second.patch
$ hg qpop
now at: first.patch
$ hg qseries
first.patch
second.patch
$ hg qapplied
first.patch
$ cat file1
line 1
line 2
line 3

Notice that once we have popped a patch or two patches, the output of qseries remains the same, while that of qapplied has changed.

While qpush and qpop each operate on a single patch at a time by default, you can push and pop many patches in one go. The hg -a option to qpush causes it to push all unapplied patches, while the -a option to qpop causes it to pop all applied patches. (For some more ways to push and pop many patches, see the section called “Getting the best performance out of MQ” below.)

$ hg qpush -a
applying second.patch
now at: second.patch
$ cat file1
line 1
line 2
line 3
line 4

Several MQ commands check the working directory before they do anything, and fail if they find any modifications. They do this to ensure that you won't lose any changes that you have made, but not yet incorporated into a patch. The example below illustrates this; the qnew command will not create a new patch if there are outstanding changes, caused in this case by the hg add of file3.

$ echo 'file 3, line 1' >> file3
$ hg qnew add-file3.patch
$ hg qnew -f add-file3.patch
abort: patch "add-file3.patch" already exists

Commands that check the working directory all take an “I know what I'm doing” option, which is always named -f. The exact meaning of -f depends on the command. For example, hg qnew hg -f will incorporate any outstanding changes into the new patch it creates, but hg qpop hg -f will revert modifications to any files affected by the patch that it is popping. Be sure to read the documentation for a command's -f option before you use it!

The qrefresh command always refreshes the topmost applied patch. This means that you can suspend work on one patch (by refreshing it), pop or push to make a different patch the top, and work on that patch for a while.

Here's an example that illustrates how you can use this ability. Let's say you're developing a new feature as two patches. The first is a change to the core of your software, and the second—layered on top of the first—changes the user interface to use the code you just added to the core. If you notice a bug in the core while you're working on the UI patch, it's easy to fix the core. Simply qrefresh the UI patch to save your in-progress changes, and qpop down to the core patch. Fix the core bug, qrefresh the core patch, and qpush back to the UI patch to continue where you left off.

If you look at the file headers in a patch, you will notice that the pathnames usually have an extra component on the front that isn't present in the actual path name. This is a holdover from the way that people used to generate patches (people still do this, but it's somewhat rare with modern revision control tools).

Alice would unpack a tarball, edit her files, then decide that she wanted to create a patch. So she'd rename her working directory, unpack the tarball again (hence the need for the rename), and use the -r and -N options to diff to recursively generate a patch between the unmodified directory and the modified one. The result would be that the name of the unmodified directory would be at the front of the left-hand path in every file header, and the name of the modified directory would be at the front of the right-hand path.

Since someone receiving a patch from the Alices of the net would be unlikely to have unmodified and modified directories with exactly the same names, the patch command has a -p option that indicates the number of leading path name components to strip when trying to apply a patch. This number is called the strip count.

An option of “-p1” means “use a strip count of one”. If patch sees a file name foo/bar/baz in a file header, it will strip foo and try to patch a file named bar/baz. (Strictly speaking, the strip count refers to the number of path separators (and the components that go with them ) to strip. A strip count of one will turn foo/bar into bar, but /foo/bar (notice the extra leading slash) into foo/bar.)

The “standard” strip count for patches is one; almost all patches contain one leading path name component that needs to be stripped. Mercurial's hg diff command generates path names in this form, and the hg import command and MQ expect patches to have a strip count of one.

If you receive a patch from someone that you want to add to your patch queue, and the patch needs a strip count other than one, you cannot just qimport the patch, because qimport does not yet have a -p option (see issue 311). Your best bet is to qnew a patch of your own, then use patch -pN to apply their patch, followed by hg addremove to pick up any files added or removed by the patch, followed by hg qrefresh. This complexity may become unnecessary; see issue 311 for details.

When patch applies a hunk, it tries a handful of successively less accurate strategies to try to make the hunk apply. This falling-back technique often makes it possible to take a patch that was generated against an old version of a file, and apply it against a newer version of that file.

First, patch tries an exact match, where the line numbers, the context, and the text to be modified must apply exactly. If it cannot make an exact match, it tries to find an exact match for the context, without honouring the line numbering information. If this succeeds, it prints a line of output saying that the hunk was applied, but at some offset from the original line number.

If a context-only match fails, patch removes the first and last lines of the context, and tries a reduced context-only match. If the hunk with reduced context succeeds, it prints a message saying that it applied the hunk with a fuzz factor (the number after the fuzz factor indicates how many lines of context patch had to trim before the patch applied).

When neither of these techniques works, patch prints a message saying that the hunk in question was rejected. It saves rejected hunks (also simply called “rejects”) to a file with the same name, and an added .rej extension. It also saves an unmodified copy of the file with a .orig extension; the copy of the file without any extensions will contain any changes made by hunks that did apply cleanly. If you have a patch that modifies foo with six hunks, and one of them fails to apply, you will have: an unmodified foo.orig, a foo.rej containing one hunk, and foo, containing the changes made by the five successful hunks.

There are a few useful things to know about how patch works with files.

While applying a hunk at an offset, or with a fuzz factor, will often be completely successful, these inexact techniques naturally leave open the possibility of corrupting the patched file. The most common cases typically involve applying a patch twice, or at an incorrect location in the file. If patch or qpush ever mentions an offset or fuzz factor, you should make sure that the modified files are correct afterwards.

It's often a good idea to refresh a patch that has applied with an offset or fuzz factor; refreshing the patch generates new context information that will make it apply cleanly. I say “often,” not “always,” because sometimes refreshing a patch will make it fail to apply against a different revision of the underlying files. In some cases, such as when you're maintaining a patch that must sit on top of multiple versions of a source tree, it's acceptable to have a patch apply with some fuzz, provided you've verified the results of the patching process in such cases.

If qpush fails to apply a patch, it will print an error message and exit. If it has left .rej files behind, it is usually best to fix up the rejected hunks before you push more patches or do any further work.

If your patch used to apply cleanly, and no longer does because you've changed the underlying code that your patches are based on, Mercurial Queues can help; see the section called “Updating your patches when the underlying code changes” for details.

Unfortunately, there aren't any great techniques for dealing with rejected hunks. Most often, you'll need to view the .rej file and edit the target file, applying the rejected hunks by hand.

A Linux kernel hacker, Chris Mason (the author of Mercurial Queues), wrote a tool called mpatch (http://oss.oracle.com/~mason/mpatch/), which takes a simple approach to automating the application of hunks rejected by patch. The mpatch command can help with four common reasons that a hunk may be rejected:

If you use mpatch, you should be doubly careful to check your results when you're done. In fact, mpatch enforces this method of double-checking the tool's output, by automatically dropping you into a merge program when it has done its job, so that you can verify its work and finish off any remaining merges.

If you want to get rid of a patch, use the hg qdelete command to delete the patch file and remove its entry from the patch series. If you try to delete a patch that is still applied, hg qdelete will refuse.

$ hg init myrepo
$ cd myrepo
$ hg qinit
$ hg qnew bad.patch
$ echo a > a
$ hg add a
$ hg qrefresh
$ hg qdelete bad.patch
abort: cannot delete applied patch bad.patch
$ hg qpop
patch queue now empty
$ hg qdelete bad.patch

Once you're done working on a patch and want to turn it into a permanent changeset, use the hg qfinish command. Pass a revision to the command to identify the patch that you want to turn into a regular changeset; this patch must already be applied.

$ hg qnew good.patch
$ echo a > a
$ hg add a
$ hg qrefresh -m 'Good change'
$ hg qfinish tip
$ hg qapplied
$ hg tip --style=compact
0[tip]   1a7ef9f28379   2009-05-05 06:55 +0000   bos
  Good change

The hg qfinish command accepts an --all or -a option, which turns all applied patches into regular changesets.

It is also possible to turn an existing changeset into a patch, by passing the -r option to hg qimport.

$ hg qimport -r tip
$ hg qapplied
0.diff

Note that it only makes sense to convert a changeset into a patch if you have not propagated that changeset into any other repositories. The imported changeset's ID will change every time you refresh the patch, which will make Mercurial treat it as unrelated to the original changeset if you have pushed it somewhere else.

MQ helps you to work with the .hg/patches directory as a repository; when you prepare a repository for working with patches using qinit, you can pass the hg -c option to create the .hg/patches directory as a Mercurial repository.

	Note
	If you forget to use the hg -c option, you can simply go into the .hg/patches directory at any time and run hg init. Don't forget to add an entry for the status file to the .hgignore file, though (hg qinit hg -c does this for you automatically); you really don't want to manage the status file.

As a convenience, if MQ notices that the .hg/patches directory is a repository, it will automatically hg add every patch that you create and import.

MQ provides a shortcut command, qcommit, that runs hg commit in the .hg/patches directory. This saves some bothersome typing.

Finally, as a convenience to manage the patch directory, you can define the alias mq on Unix systems. For example, on Linux systems using the bash shell, you can include the following snippet in your ~/.bashrc.

alias mq=`hg -R $(hg root)/.hg/patches'

You can then issue commands of the form mq pull from the main repository.

MQ's support for working with a repository full of patches is limited in a few small respects.

MQ cannot automatically detect changes that you make to the patch directory. If you hg pull, manually edit, or hg update changes to patches or the series file, you will have to hg qpop hg -a and then hg qpush hg -a in the underlying repository to see those changes show up there. If you forget to do this, you can confuse MQ's idea of which patches are applied.

Because the overhead of dropping files into a new Mercurial repository is so low, it makes a lot of sense to manage patches this way even if you simply want to make a few changes to a source tarball that you downloaded.

Begin by downloading and unpacking the source tarball, and turning it into a Mercurial repository.

$ download netplug-1.2.5.tar.bz2
$ tar jxf netplug-1.2.5.tar.bz2
$ cd netplug-1.2.5
$ hg init
$ hg commit -q --addremove --message netplug-1.2.5
$ cd ..
$ hg clone netplug-1.2.5 netplug
updating working directory
18 files updated, 0 files merged, 0 files removed, 0 files unresolved

Continue by creating a patch stack and making your changes.

$ cd netplug
$ hg qinit
$ hg qnew -m 'fix build problem with gcc 4' build-fix.patch
$ perl -pi -e 's/int addr_len/socklen_t addr_len/' netlink.c
$ hg qrefresh
$ hg tip -p
changeset:   1:355c94c5387f
tag:         qtip
tag:         build-fix.patch
tag:         tip
tag:         qbase
user:        Bryan O'Sullivan <[email protected]>
date:        Tue May 05 06:55:40 2009 +0000
summary:     fix build problem with gcc 4

diff -r cec109bd7cd3 -r 355c94c5387f netlink.c
--- a/netlink.c	Tue May 05 06:55:39 2009 +0000
+++ b/netlink.c	Tue May 05 06:55:40 2009 +0000
@@ -275,7 +275,7 @@
         exit(1);
     }
 
-    int addr_len = sizeof(addr);
+    socklen_t addr_len = sizeof(addr);
 
     if (getsockname(fd, (struct sockaddr *) &addr, &addr_len) == -1) {
         do_log(LOG_ERR, "Could not get socket details: %m");

Let's say a few weeks or months pass, and your package author releases a new version. First, bring their changes into the repository.

$ hg qpop -a
patch queue now empty
$ cd ..
$ download netplug-1.2.8.tar.bz2
$ hg clone netplug-1.2.5 netplug-1.2.8
updating working directory
18 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd netplug-1.2.8
$ hg locate -0 | xargs -0 rm
$ cd ..
$ tar jxf netplug-1.2.8.tar.bz2
$ cd netplug-1.2.8
$ hg commit --addremove --message netplug-1.2.8

The pipeline starting with hg locate above deletes all files in the working directory, so that hg commit's --addremove option can actually tell which files have really been removed in the newer version of the source.

Finally, you can apply your patches on top of the new tree.

$ cd ../netplug
$ hg pull ../netplug-1.2.8
pulling from ../netplug-1.2.8
searching for changes
adding changesets
adding manifests
adding file changes
added 1 changesets with 12 changes to 12 files
(run 'hg update' to get a working copy)
$ hg qpush -a
(working directory not at tip)
applying build-fix.patch
now at: build-fix.patch

MQ provides a command, qfold that lets you combine entire patches. This “folds” the patches you name, in the order you name them, into the topmost applied patch, and concatenates their descriptions onto the end of its description. The patches that you fold must be unapplied before you fold them.

The order in which you fold patches matters. If your topmost applied patch is foo, and you qfold bar and quux into it, you will end up with a patch that has the same effect as if you applied first foo, then bar, followed by quux.

Merging part of one patch into another is more difficult than combining entire patches.

If you want to move changes to entire files, you can use filterdiff's -i and -x options to choose the modifications to snip out of one patch, concatenating its output onto the end of the patch you want to merge into. You usually won't need to modify the patch you've merged the changes from. Instead, MQ will report some rejected hunks when you qpush it (from the hunks you moved into the other patch), and you can simply qrefresh the patch to drop the duplicate hunks.

If you have a patch that has multiple hunks modifying a file, and you only want to move a few of those hunks, the job becomes more messy, but you can still partly automate it. Use lsdiff -nvv to print some metadata about the patch.

$ lsdiff -nvv remove-redundant-null-checks.patch
22	File #1  	a/drivers/char/agp/sgi-agp.c
	24	Hunk #1	static int __devinit agp_sgi_init(void)
37	File #2  	a/drivers/char/hvcs.c
	39	Hunk #1	static struct tty_operations hvcs_ops = 
	53	Hunk #2	static int hvcs_alloc_index_list(int n)
69	File #3  	a/drivers/message/fusion/mptfc.c
	71	Hunk #1	mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, in
85	File #4  	a/drivers/message/fusion/mptsas.c
	87	Hunk #1	mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
98	File #5  	a/drivers/net/fs_enet/fs_enet-mii.c
	100	Hunk #1	static struct fs_enet_mii_bus *create_bu
111	File #6  	a/drivers/net/wireless/ipw2200.c
	113	Hunk #1	static struct ipw_fw_error *ipw_alloc_er
	126	Hunk #2	static ssize_t clear_error(struct device
	140	Hunk #3	static void ipw_irq_tasklet(struct ipw_p
	150	Hunk #4	static void ipw_pci_remove(struct pci_de
164	File #7  	a/drivers/scsi/libata-scsi.c
	166	Hunk #1	int ata_cmd_ioctl(struct scsi_device *sc
178	File #8  	a/drivers/video/au1100fb.c
	180	Hunk #1	void __exit au1100fb_cleanup(void)

This command prints three different kinds of number:

You'll have to use some visual inspection, and reading of the patch, to identify the file and hunk numbers you'll want, but you can then pass them to to filterdiff's --files and --hunks options, to select exactly the file and hunk you want to extract.

Once you have this hunk, you can concatenate it onto the end of your destination patch and continue with the remainder of the section called “Combining entire patches”.