]>
Commit | Line | Data |
---|---|---|
609d99a3 | 1 | .. _applying_patches: |
754c7976 | 2 | |
9299c3e9 MCC |
3 | Applying Patches To The Linux Kernel |
4 | ++++++++++++++++++++++++++++++++++++ | |
754c7976 | 5 | |
9299c3e9 MCC |
6 | Original by: |
7 | Jesper Juhl, August 2005 | |
8 | ||
9 | Last update: | |
330ae7e9 | 10 | 2016-09-14 |
754c7976 | 11 | |
67972a53 JC |
12 | .. note:: |
13 | ||
14 | This document is obsolete. In most cases, rather than using ``patch`` | |
15 | manually, you'll almost certainly want to look at using Git instead. | |
754c7976 JJ |
16 | |
17 | A frequently asked question on the Linux Kernel Mailing List is how to apply | |
18 | a patch to the kernel or, more specifically, what base kernel a patch for | |
19 | one of the many trees/branches should be applied to. Hopefully this document | |
20 | will explain this to you. | |
21 | ||
22 | In addition to explaining how to apply and revert patches, a brief | |
23 | description of the different kernel trees (and examples of how to apply | |
24 | their specific patches) is also provided. | |
25 | ||
26 | ||
27 | What is a patch? | |
9299c3e9 MCC |
28 | ================ |
29 | ||
30 | A patch is a small text document containing a delta of changes between two | |
31 | different versions of a source tree. Patches are created with the ``diff`` | |
754c7976 | 32 | program. |
9299c3e9 | 33 | |
754c7976 JJ |
34 | To correctly apply a patch you need to know what base it was generated from |
35 | and what new version the patch will change the source tree into. These | |
36 | should both be present in the patch file metadata or be possible to deduce | |
37 | from the filename. | |
38 | ||
39 | ||
40 | How do I apply or revert a patch? | |
9299c3e9 MCC |
41 | ================================= |
42 | ||
43 | You apply a patch with the ``patch`` program. The patch program reads a diff | |
754c7976 JJ |
44 | (or patch) file and makes the changes to the source tree described in it. |
45 | ||
46 | Patches for the Linux kernel are generated relative to the parent directory | |
47 | holding the kernel source dir. | |
48 | ||
49 | This means that paths to files inside the patch file contain the name of the | |
50 | kernel source directories it was generated against (or some other directory | |
51 | names like "a/" and "b/"). | |
9299c3e9 | 52 | |
754c7976 JJ |
53 | Since this is unlikely to match the name of the kernel source dir on your |
54 | local machine (but is often useful info to see what version an otherwise | |
55 | unlabeled patch was generated against) you should change into your kernel | |
56 | source directory and then strip the first element of the path from filenames | |
9299c3e9 MCC |
57 | in the patch file when applying it (the ``-p1`` argument to ``patch`` does |
58 | this). | |
754c7976 JJ |
59 | |
60 | To revert a previously applied patch, use the -R argument to patch. | |
1b49ecf2 | 61 | So, if you applied a patch like this:: |
9299c3e9 | 62 | |
754c7976 JJ |
63 | patch -p1 < ../patch-x.y.z |
64 | ||
1b49ecf2 | 65 | You can revert (undo) it like this:: |
9299c3e9 | 66 | |
754c7976 JJ |
67 | patch -R -p1 < ../patch-x.y.z |
68 | ||
69 | ||
9299c3e9 MCC |
70 | How do I feed a patch/diff file to ``patch``? |
71 | ============================================= | |
72 | ||
73 | This (as usual with Linux and other UNIX like operating systems) can be | |
754c7976 | 74 | done in several different ways. |
9299c3e9 | 75 | |
754c7976 | 76 | In all the examples below I feed the file (in uncompressed form) to patch |
1b49ecf2 | 77 | via stdin using the following syntax:: |
9299c3e9 | 78 | |
754c7976 JJ |
79 | patch -p1 < path/to/patch-x.y.z |
80 | ||
81 | If you just want to be able to follow the examples below and don't want to | |
82 | know of more than one way to use patch, then you can stop reading this | |
83 | section here. | |
84 | ||
85 | Patch can also get the name of the file to use via the -i argument, like | |
1b49ecf2 | 86 | this:: |
9299c3e9 | 87 | |
754c7976 JJ |
88 | patch -p1 -i path/to/patch-x.y.z |
89 | ||
330ae7e9 | 90 | If your patch file is compressed with gzip or xz and you don't want to |
754c7976 | 91 | uncompress it before applying it, then you can feed it to patch like this |
1b49ecf2 | 92 | instead:: |
9299c3e9 | 93 | |
330ae7e9 MCC |
94 | xzcat path/to/patch-x.y.z.xz | patch -p1 |
95 | bzcat path/to/patch-x.y.z.gz | patch -p1 | |
754c7976 JJ |
96 | |
97 | If you wish to uncompress the patch file by hand first before applying it | |
98 | (what I assume you've done in the examples below), then you simply run | |
1b49ecf2 | 99 | gunzip or xz on the file -- like this:: |
9299c3e9 | 100 | |
754c7976 | 101 | gunzip patch-x.y.z.gz |
330ae7e9 | 102 | xz -d patch-x.y.z.xz |
754c7976 JJ |
103 | |
104 | Which will leave you with a plain text patch-x.y.z file that you can feed to | |
9299c3e9 | 105 | patch via stdin or the ``-i`` argument, as you prefer. |
754c7976 | 106 | |
9299c3e9 | 107 | A few other nice arguments for patch are ``-s`` which causes patch to be silent |
754c7976 | 108 | except for errors which is nice to prevent errors from scrolling out of the |
9299c3e9 MCC |
109 | screen too fast, and ``--dry-run`` which causes patch to just print a listing of |
110 | what would happen, but doesn't actually make any changes. Finally ``--verbose`` | |
754c7976 JJ |
111 | tells patch to print more information about the work being done. |
112 | ||
113 | ||
114 | Common errors when patching | |
9299c3e9 MCC |
115 | =========================== |
116 | ||
117 | When patch applies a patch file it attempts to verify the sanity of the | |
754c7976 | 118 | file in different ways. |
9299c3e9 | 119 | |
2d69049a | 120 | Checking that the file looks like a valid patch file and checking the code |
754c7976 JJ |
121 | around the bits being modified matches the context provided in the patch are |
122 | just two of the basic sanity checks patch does. | |
123 | ||
124 | If patch encounters something that doesn't look quite right it has two | |
125 | options. It can either refuse to apply the changes and abort or it can try | |
126 | to find a way to make the patch apply with a few minor changes. | |
127 | ||
128 | One example of something that's not 'quite right' that patch will attempt to | |
129 | fix up is if all the context matches, the lines being changed match, but the | |
130 | line numbers are different. This can happen, for example, if the patch makes | |
131 | a change in the middle of the file but for some reasons a few lines have | |
132 | been added or removed near the beginning of the file. In that case | |
133 | everything looks good it has just moved up or down a bit, and patch will | |
134 | usually adjust the line numbers and apply the patch. | |
135 | ||
136 | Whenever patch applies a patch that it had to modify a bit to make it fit | |
9299c3e9 | 137 | it'll tell you about it by saying the patch applied with **fuzz**. |
754c7976 JJ |
138 | You should be wary of such changes since even though patch probably got it |
139 | right it doesn't /always/ get it right, and the result will sometimes be | |
140 | wrong. | |
141 | ||
142 | When patch encounters a change that it can't fix up with fuzz it rejects it | |
9299c3e9 | 143 | outright and leaves a file with a ``.rej`` extension (a reject file). You can |
90f2447d | 144 | read this file to see exactly what change couldn't be applied, so you can |
754c7976 JJ |
145 | go fix it up by hand if you wish. |
146 | ||
c594a50d | 147 | If you don't have any third-party patches applied to your kernel source, but |
754c7976 JJ |
148 | only patches from kernel.org and you apply the patches in the correct order, |
149 | and have made no modifications yourself to the source files, then you should | |
150 | never see a fuzz or reject message from patch. If you do see such messages | |
151 | anyway, then there's a high risk that either your local source tree or the | |
152 | patch file is corrupted in some way. In that case you should probably try | |
90f2447d | 153 | re-downloading the patch and if things are still not OK then you'd be advised |
754c7976 JJ |
154 | to start with a fresh tree downloaded in full from kernel.org. |
155 | ||
156 | Let's look a bit more at some of the messages patch can produce. | |
157 | ||
9299c3e9 | 158 | If patch stops and presents a ``File to patch:`` prompt, then patch could not |
754c7976 JJ |
159 | find a file to be patched. Most likely you forgot to specify -p1 or you are |
160 | in the wrong directory. Less often, you'll find patches that need to be | |
9299c3e9 | 161 | applied with ``-p0`` instead of ``-p1`` (reading the patch file should reveal if |
c594a50d | 162 | this is the case -- if so, then this is an error by the person who created |
754c7976 JJ |
163 | the patch but is not fatal). |
164 | ||
9299c3e9 | 165 | If you get ``Hunk #2 succeeded at 1887 with fuzz 2 (offset 7 lines).`` or a |
754c7976 JJ |
166 | message similar to that, then it means that patch had to adjust the location |
167 | of the change (in this example it needed to move 7 lines from where it | |
168 | expected to make the change to make it fit). | |
9299c3e9 | 169 | |
754c7976 JJ |
170 | The resulting file may or may not be OK, depending on the reason the file |
171 | was different than expected. | |
9299c3e9 | 172 | |
754c7976 JJ |
173 | This often happens if you try to apply a patch that was generated against a |
174 | different kernel version than the one you are trying to patch. | |
175 | ||
9299c3e9 | 176 | If you get a message like ``Hunk #3 FAILED at 2387.``, then it means that the |
754c7976 | 177 | patch could not be applied correctly and the patch program was unable to |
9299c3e9 MCC |
178 | fuzz its way through. This will generate a ``.rej`` file with the change that |
179 | caused the patch to fail and also a ``.orig`` file showing you the original | |
754c7976 JJ |
180 | content that couldn't be changed. |
181 | ||
9299c3e9 | 182 | If you get ``Reversed (or previously applied) patch detected! Assume -R? [n]`` |
754c7976 JJ |
183 | then patch detected that the change contained in the patch seems to have |
184 | already been made. | |
9299c3e9 | 185 | |
754c7976 JJ |
186 | If you actually did apply this patch previously and you just re-applied it |
187 | in error, then just say [n]o and abort this patch. If you applied this patch | |
188 | previously and actually intended to revert it, but forgot to specify -R, | |
9299c3e9 MCC |
189 | then you can say [**y**]es here to make patch revert it for you. |
190 | ||
754c7976 JJ |
191 | This can also happen if the creator of the patch reversed the source and |
192 | destination directories when creating the patch, and in that case reverting | |
193 | the patch will in fact apply it. | |
194 | ||
9299c3e9 MCC |
195 | A message similar to ``patch: **** unexpected end of file in patch`` or |
196 | ``patch unexpectedly ends in middle of line`` means that patch could make no | |
197 | sense of the file you fed to it. Either your download is broken, you tried to | |
198 | feed patch a compressed patch file without uncompressing it first, or the patch | |
c594a50d RD |
199 | file that you are using has been mangled by a mail client or mail transfer |
200 | agent along the way somewhere, e.g., by splitting a long line into two lines. | |
201 | Often these warnings can easily be fixed by joining (concatenating) the | |
202 | two lines that had been split. | |
754c7976 JJ |
203 | |
204 | As I already mentioned above, these errors should never happen if you apply | |
205 | a patch from kernel.org to the correct version of an unmodified source tree. | |
206 | So if you get these errors with kernel.org patches then you should probably | |
c594a50d | 207 | assume that either your patch file or your tree is broken and I'd advise you |
754c7976 JJ |
208 | to start over with a fresh download of a full kernel tree and the patch you |
209 | wish to apply. | |
210 | ||
211 | ||
9299c3e9 MCC |
212 | Are there any alternatives to ``patch``? |
213 | ======================================== | |
90f2447d | 214 | |
9299c3e9 MCC |
215 | |
216 | Yes there are alternatives. | |
217 | ||
218 | You can use the ``interdiff`` program (http://cyberelk.net/tim/patchutils/) to | |
90f2447d JJ |
219 | generate a patch representing the differences between two patches and then |
220 | apply the result. | |
9299c3e9 | 221 | |
330ae7e9 | 222 | This will let you move from something like 4.7.2 to 4.7.3 in a single |
754c7976 JJ |
223 | step. The -z flag to interdiff will even let you feed it patches in gzip or |
224 | bzip2 compressed form directly without the use of zcat or bzcat or manual | |
225 | decompression. | |
226 | ||
1b49ecf2 | 227 | Here's how you'd go from 4.7.2 to 4.7.3 in a single step:: |
9299c3e9 | 228 | |
330ae7e9 | 229 | interdiff -z ../patch-4.7.2.gz ../patch-4.7.3.gz | patch -p1 |
754c7976 JJ |
230 | |
231 | Although interdiff may save you a step or two you are generally advised to | |
232 | do the additional steps since interdiff can get things wrong in some cases. | |
233 | ||
9299c3e9 | 234 | Another alternative is ``ketchup``, which is a python script for automatic |
754c7976 JJ |
235 | downloading and applying of patches (http://www.selenic.com/ketchup/). |
236 | ||
9299c3e9 | 237 | Other nice tools are diffstat, which shows a summary of changes made by a |
c594a50d RD |
238 | patch; lsdiff, which displays a short listing of affected files in a patch |
239 | file, along with (optionally) the line numbers of the start of each patch; | |
240 | and grepdiff, which displays a list of the files modified by a patch where | |
754c7976 JJ |
241 | the patch contains a given regular expression. |
242 | ||
243 | ||
244 | Where can I download the patches? | |
9299c3e9 MCC |
245 | ================================= |
246 | ||
247 | The patches are available at http://kernel.org/ | |
754c7976 JJ |
248 | Most recent patches are linked from the front page, but they also have |
249 | specific homes. | |
250 | ||
330ae7e9 | 251 | The 4.x.y (-stable) and 4.x patches live at |
9299c3e9 | 252 | |
3bdadc86 | 253 | https://www.kernel.org/pub/linux/kernel/v4.x/ |
754c7976 JJ |
254 | |
255 | The -rc patches live at | |
9299c3e9 | 256 | |
3bdadc86 | 257 | https://www.kernel.org/pub/linux/kernel/v4.x/testing/ |
754c7976 JJ |
258 | |
259 | ||
330ae7e9 MCC |
260 | The 4.x kernels |
261 | =============== | |
9299c3e9 MCC |
262 | |
263 | These are the base stable releases released by Linus. The highest numbered | |
754c7976 JJ |
264 | release is the most recent. |
265 | ||
c594a50d | 266 | If regressions or other serious flaws are found, then a -stable fix patch |
330ae7e9 | 267 | will be released (see below) on top of this base. Once a new 4.x base |
754c7976 | 268 | kernel is released, a patch is made available that is a delta between the |
330ae7e9 | 269 | previous 4.x kernel and the new one. |
754c7976 | 270 | |
330ae7e9 MCC |
271 | To apply a patch moving from 4.6 to 4.7, you'd do the following (note |
272 | that such patches do **NOT** apply on top of 4.x.y kernels but on top of the | |
273 | base 4.x kernel -- if you need to move from 4.x.y to 4.x+1 you need to | |
274 | first revert the 4.x.y patch). | |
754c7976 | 275 | |
1b49ecf2 | 276 | Here are some examples:: |
9299c3e9 | 277 | |
330ae7e9 MCC |
278 | # moving from 4.6 to 4.7 |
279 | ||
280 | $ cd ~/linux-4.6 # change to kernel source dir | |
281 | $ patch -p1 < ../patch-4.7 # apply the 4.7 patch | |
9299c3e9 | 282 | $ cd .. |
330ae7e9 | 283 | $ mv linux-4.6 linux-4.7 # rename source dir |
754c7976 | 284 | |
330ae7e9 MCC |
285 | # moving from 4.6.1 to 4.7 |
286 | ||
287 | $ cd ~/linux-4.6.1 # change to kernel source dir | |
288 | $ patch -p1 -R < ../patch-4.6.1 # revert the 4.6.1 patch | |
289 | # source dir is now 4.6 | |
290 | $ patch -p1 < ../patch-4.7 # apply new 4.7 patch | |
9299c3e9 | 291 | $ cd .. |
330ae7e9 | 292 | $ mv linux-4.6.1 linux-4.7 # rename source dir |
754c7976 JJ |
293 | |
294 | ||
330ae7e9 MCC |
295 | The 4.x.y kernels |
296 | ================= | |
9299c3e9 | 297 | |
330ae7e9 | 298 | Kernels with 3-digit versions are -stable kernels. They contain small(ish) |
754c7976 | 299 | critical fixes for security problems or significant regressions discovered |
330ae7e9 | 300 | in a given 4.x kernel. |
754c7976 JJ |
301 | |
302 | This is the recommended branch for users who want the most recent stable | |
303 | kernel and are not interested in helping test development/experimental | |
304 | versions. | |
305 | ||
330ae7e9 | 306 | If no 4.x.y kernel is available, then the highest numbered 4.x kernel is |
754c7976 JJ |
307 | the current stable kernel. |
308 | ||
9299c3e9 MCC |
309 | .. note:: |
310 | ||
311 | The -stable team usually do make incremental patches available as well | |
c594a50d RD |
312 | as patches against the latest mainline release, but I only cover the |
313 | non-incremental ones below. The incremental ones can be found at | |
3bdadc86 | 314 | https://www.kernel.org/pub/linux/kernel/v4.x/incr/ |
c594a50d | 315 | |
330ae7e9 MCC |
316 | These patches are not incremental, meaning that for example the 4.7.3 |
317 | patch does not apply on top of the 4.7.2 kernel source, but rather on top | |
318 | of the base 4.7 kernel source. | |
9299c3e9 | 319 | |
330ae7e9 MCC |
320 | So, in order to apply the 4.7.3 patch to your existing 4.7.2 kernel |
321 | source you have to first back out the 4.7.2 patch (so you are left with a | |
322 | base 4.7 kernel source) and then apply the new 4.7.3 patch. | |
754c7976 | 323 | |
1b49ecf2 | 324 | Here's a small example:: |
754c7976 | 325 | |
330ae7e9 MCC |
326 | $ cd ~/linux-4.7.2 # change to the kernel source dir |
327 | $ patch -p1 -R < ../patch-4.7.2 # revert the 4.7.2 patch | |
328 | $ patch -p1 < ../patch-4.7.3 # apply the new 4.7.3 patch | |
9299c3e9 | 329 | $ cd .. |
330ae7e9 | 330 | $ mv linux-4.7.2 linux-4.7.3 # rename the kernel source dir |
754c7976 JJ |
331 | |
332 | The -rc kernels | |
9299c3e9 MCC |
333 | =============== |
334 | ||
335 | These are release-candidate kernels. These are development kernels released | |
754c7976 JJ |
336 | by Linus whenever he deems the current git (the kernel's source management |
337 | tool) tree to be in a reasonably sane state adequate for testing. | |
338 | ||
339 | These kernels are not stable and you should expect occasional breakage if | |
340 | you intend to run them. This is however the most stable of the main | |
341 | development branches and is also what will eventually turn into the next | |
342 | stable kernel, so it is important that it be tested by as many people as | |
343 | possible. | |
344 | ||
345 | This is a good branch to run for people who want to help out testing | |
346 | development kernels but do not want to run some of the really experimental | |
347 | stuff (such people should see the sections about -git and -mm kernels below). | |
348 | ||
330ae7e9 MCC |
349 | The -rc patches are not incremental, they apply to a base 4.x kernel, just |
350 | like the 4.x.y patches described above. The kernel version before the -rcN | |
754c7976 JJ |
351 | suffix denotes the version of the kernel that this -rc kernel will eventually |
352 | turn into. | |
9299c3e9 | 353 | |
330ae7e9 MCC |
354 | So, 4.8-rc5 means that this is the fifth release candidate for the 4.8 |
355 | kernel and the patch should be applied on top of the 4.7 kernel source. | |
754c7976 | 356 | |
1b49ecf2 | 357 | Here are 3 examples of how to apply these patches:: |
9299c3e9 | 358 | |
330ae7e9 MCC |
359 | # first an example of moving from 4.7 to 4.8-rc3 |
360 | ||
361 | $ cd ~/linux-4.7 # change to the 4.7 source dir | |
362 | $ patch -p1 < ../patch-4.8-rc3 # apply the 4.8-rc3 patch | |
9299c3e9 | 363 | $ cd .. |
330ae7e9 | 364 | $ mv linux-4.7 linux-4.8-rc3 # rename the source dir |
754c7976 | 365 | |
330ae7e9 MCC |
366 | # now let's move from 4.8-rc3 to 4.8-rc5 |
367 | ||
368 | $ cd ~/linux-4.8-rc3 # change to the 4.8-rc3 dir | |
369 | $ patch -p1 -R < ../patch-4.8-rc3 # revert the 4.8-rc3 patch | |
370 | $ patch -p1 < ../patch-4.8-rc5 # apply the new 4.8-rc5 patch | |
9299c3e9 | 371 | $ cd .. |
330ae7e9 MCC |
372 | $ mv linux-4.8-rc3 linux-4.8-rc5 # rename the source dir |
373 | ||
374 | # finally let's try and move from 4.7.3 to 4.8-rc5 | |
754c7976 | 375 | |
330ae7e9 MCC |
376 | $ cd ~/linux-4.7.3 # change to the kernel source dir |
377 | $ patch -p1 -R < ../patch-4.7.3 # revert the 4.7.3 patch | |
378 | $ patch -p1 < ../patch-4.8-rc5 # apply new 4.8-rc5 patch | |
9299c3e9 | 379 | $ cd .. |
330ae7e9 | 380 | $ mv linux-4.7.3 linux-4.8-rc5 # rename the kernel source dir |
754c7976 JJ |
381 | |
382 | ||
383 | The -git kernels | |
9299c3e9 MCC |
384 | ================ |
385 | ||
386 | These are daily snapshots of Linus' kernel tree (managed in a git | |
754c7976 JJ |
387 | repository, hence the name). |
388 | ||
389 | These patches are usually released daily and represent the current state of | |
c594a50d | 390 | Linus's tree. They are more experimental than -rc kernels since they are |
754c7976 JJ |
391 | generated automatically without even a cursory glance to see if they are |
392 | sane. | |
393 | ||
330ae7e9 MCC |
394 | -git patches are not incremental and apply either to a base 4.x kernel or |
395 | a base 4.x-rc kernel -- you can see which from their name. | |
396 | A patch named 4.7-git1 applies to the 4.7 kernel source and a patch | |
397 | named 4.8-rc3-git2 applies to the source of the 4.8-rc3 kernel. | |
754c7976 | 398 | |
1b49ecf2 | 399 | Here are some examples of how to apply these patches:: |
754c7976 | 400 | |
330ae7e9 | 401 | # moving from 4.7 to 4.7-git1 |
754c7976 | 402 | |
330ae7e9 MCC |
403 | $ cd ~/linux-4.7 # change to the kernel source dir |
404 | $ patch -p1 < ../patch-4.7-git1 # apply the 4.7-git1 patch | |
405 | $ cd .. | |
406 | $ mv linux-4.7 linux-4.7-git1 # rename the kernel source dir | |
754c7976 | 407 | |
330ae7e9 | 408 | # moving from 4.7-git1 to 4.8-rc2-git3 |
9299c3e9 | 409 | |
330ae7e9 MCC |
410 | $ cd ~/linux-4.7-git1 # change to the kernel source dir |
411 | $ patch -p1 -R < ../patch-4.7-git1 # revert the 4.7-git1 patch | |
412 | # we now have a 4.7 kernel | |
413 | $ patch -p1 < ../patch-4.8-rc2 # apply the 4.8-rc2 patch | |
414 | # the kernel is now 4.8-rc2 | |
415 | $ patch -p1 < ../patch-4.8-rc2-git3 # apply the 4.8-rc2-git3 patch | |
416 | # the kernel is now 4.8-rc2-git3 | |
417 | $ cd .. | |
418 | $ mv linux-4.7-git1 linux-4.8-rc2-git3 # rename source dir | |
754c7976 | 419 | |
9299c3e9 | 420 | |
330ae7e9 MCC |
421 | The -mm patches and the linux-next tree |
422 | ======================================= | |
754c7976 | 423 | |
330ae7e9 | 424 | The -mm patches are experimental patches released by Andrew Morton. |
9299c3e9 | 425 | |
330ae7e9 MCC |
426 | In the past, -mm tree were used to also test subsystem patches, but this |
427 | function is now done via the | |
3a61badd | 428 | `linux-next <https://www.kernel.org/doc/man-pages/linux-next.html>` |
330ae7e9 MCC |
429 | tree. The Subsystem maintainers push their patches first to linux-next, |
430 | and, during the merge window, sends them directly to Linus. | |
754c7976 | 431 | |
330ae7e9 MCC |
432 | The -mm patches serve as a sort of proving ground for new features and other |
433 | experimental patches that aren't merged via a subsystem tree. | |
434 | Once such patches has proved its worth in -mm for a while Andrew pushes | |
435 | it on to Linus for inclusion in mainline. | |
754c7976 | 436 | |
330ae7e9 MCC |
437 | The linux-next tree is daily updated, and includes the -mm patches. |
438 | Both are in constant flux and contains many experimental features, a | |
c594a50d | 439 | lot of debugging patches not appropriate for mainline etc., and is the most |
754c7976 JJ |
440 | experimental of the branches described in this document. |
441 | ||
330ae7e9 | 442 | These patches are not appropriate for use on systems that are supposed to be |
754c7976 | 443 | stable and they are more risky to run than any of the other branches (make |
c594a50d | 444 | sure you have up-to-date backups -- that goes for any experimental kernel but |
330ae7e9 | 445 | even more so for -mm patches or using a Kernel from the linux-next tree). |
754c7976 | 446 | |
330ae7e9 MCC |
447 | Testing of -mm patches and linux-next is greatly appreciated since the whole |
448 | point of those are to weed out regressions, crashes, data corruption bugs, | |
449 | build breakage (and any other bug in general) before changes are merged into | |
450 | the more stable mainline Linus tree. | |
9299c3e9 | 451 | |
330ae7e9 MCC |
452 | But testers of -mm and linux-next should be aware that breakages are |
453 | more common than in any other tree. | |
754c7976 JJ |
454 | |
455 | ||
90f2447d JJ |
456 | This concludes this list of explanations of the various kernel trees. |
457 | I hope you are now clear on how to apply the various patches and help testing | |
458 | the kernel. | |
459 | ||
460 | Thank you's to Randy Dunlap, Rolf Eike Beer, Linus Torvalds, Bodo Eggert, | |
461 | Johannes Stezenbach, Grant Coady, Pavel Machek and others that I may have | |
462 | forgotten for their reviews and contributions to this document. |