7.AdvancedTopics.rst 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178
  1. .. _development_advancedtopics:
  2. Advanced topics
  3. ===============
  4. At this point, hopefully, you have a handle on how the development process
  5. works. There is still more to learn, however! This section will cover a
  6. number of topics which can be helpful for developers wanting to become a
  7. regular part of the Linux kernel development process.
  8. Managing patches with git
  9. -------------------------
  10. The use of distributed version control for the kernel began in early 2002,
  11. when Linus first started playing with the proprietary BitKeeper
  12. application. While BitKeeper was controversial, the approach to software
  13. version management it embodied most certainly was not. Distributed version
  14. control enabled an immediate acceleration of the kernel development
  15. project. In current times, there are several free alternatives to
  16. BitKeeper. For better or for worse, the kernel project has settled on git
  17. as its tool of choice.
  18. Managing patches with git can make life much easier for the developer,
  19. especially as the volume of those patches grows. Git also has its rough
  20. edges and poses certain hazards; it is a young and powerful tool which is
  21. still being civilized by its developers. This document will not attempt to
  22. teach the reader how to use git; that would be sufficient material for a
  23. long document in its own right. Instead, the focus here will be on how git
  24. fits into the kernel development process in particular. Developers who
  25. wish to come up to speed with git will find more information at:
  26. https://git-scm.com/
  27. https://www.kernel.org/pub/software/scm/git/docs/user-manual.html
  28. and on various tutorials found on the web.
  29. The first order of business is to read the above sites and get a solid
  30. understanding of how git works before trying to use it to make patches
  31. available to others. A git-using developer should be able to obtain a copy
  32. of the mainline repository, explore the revision history, commit changes to
  33. the tree, use branches, etc. An understanding of git's tools for the
  34. rewriting of history (such as rebase) is also useful. Git comes with its
  35. own terminology and concepts; a new user of git should know about refs,
  36. remote branches, the index, fast-forward merges, pushes and pulls, detached
  37. heads, etc. It can all be a little intimidating at the outset, but the
  38. concepts are not that hard to grasp with a bit of study.
  39. Using git to generate patches for submission by email can be a good
  40. exercise while coming up to speed.
  41. When you are ready to start putting up git trees for others to look at, you
  42. will, of course, need a server that can be pulled from. Setting up such a
  43. server with git-daemon is relatively straightforward if you have a system
  44. which is accessible to the Internet. Otherwise, free, public hosting sites
  45. (Github, for example) are starting to appear on the net. Established
  46. developers can get an account on kernel.org, but those are not easy to come
  47. by; see https://kernel.org/faq/ for more information.
  48. The normal git workflow involves the use of a lot of branches. Each line
  49. of development can be separated into a separate "topic branch" and
  50. maintained independently. Branches in git are cheap, there is no reason to
  51. not make free use of them. And, in any case, you should not do your
  52. development in any branch which you intend to ask others to pull from.
  53. Publicly-available branches should be created with care; merge in patches
  54. from development branches when they are in complete form and ready to go -
  55. not before.
  56. Git provides some powerful tools which can allow you to rewrite your
  57. development history. An inconvenient patch (one which breaks bisection,
  58. say, or which has some other sort of obvious bug) can be fixed in place or
  59. made to disappear from the history entirely. A patch series can be
  60. rewritten as if it had been written on top of today's mainline, even though
  61. you have been working on it for months. Changes can be transparently
  62. shifted from one branch to another. And so on. Judicious use of git's
  63. ability to revise history can help in the creation of clean patch sets with
  64. fewer problems.
  65. Excessive use of this capability can lead to other problems, though, beyond
  66. a simple obsession for the creation of the perfect project history.
  67. Rewriting history will rewrite the changes contained in that history,
  68. turning a tested (hopefully) kernel tree into an untested one. But, beyond
  69. that, developers cannot easily collaborate if they do not have a shared
  70. view of the project history; if you rewrite history which other developers
  71. have pulled into their repositories, you will make life much more difficult
  72. for those developers. So a simple rule of thumb applies here: history
  73. which has been exported to others should generally be seen as immutable
  74. thereafter.
  75. So, once you push a set of changes to your publicly-available server, those
  76. changes should not be rewritten. Git will attempt to enforce this rule if
  77. you try to push changes which do not result in a fast-forward merge
  78. (i.e. changes which do not share the same history). It is possible to
  79. override this check, and there may be times when it is necessary to rewrite
  80. an exported tree. Moving changesets between trees to avoid conflicts in
  81. linux-next is one example. But such actions should be rare. This is one
  82. of the reasons why development should be done in private branches (which
  83. can be rewritten if necessary) and only moved into public branches when
  84. it's in a reasonably advanced state.
  85. As the mainline (or other tree upon which a set of changes is based)
  86. advances, it is tempting to merge with that tree to stay on the leading
  87. edge. For a private branch, rebasing can be an easy way to keep up with
  88. another tree, but rebasing is not an option once a tree is exported to the
  89. world. Once that happens, a full merge must be done. Merging occasionally
  90. makes good sense, but overly frequent merges can clutter the history
  91. needlessly. Suggested technique in this case is to merge infrequently, and
  92. generally only at specific release points (such as a mainline -rc
  93. release). If you are nervous about specific changes, you can always
  94. perform test merges in a private branch. The git "rerere" tool can be
  95. useful in such situations; it remembers how merge conflicts were resolved
  96. so that you don't have to do the same work twice.
  97. One of the biggest recurring complaints about tools like git is this: the
  98. mass movement of patches from one repository to another makes it easy to
  99. slip in ill-advised changes which go into the mainline below the review
  100. radar. Kernel developers tend to get unhappy when they see that kind of
  101. thing happening; putting up a git tree with unreviewed or off-topic patches
  102. can affect your ability to get trees pulled in the future. Quoting Linus:
  103. ::
  104. You can send me patches, but for me to pull a git patch from you, I
  105. need to know that you know what you're doing, and I need to be able
  106. to trust things *without* then having to go and check every
  107. individual change by hand.
  108. (https://lwn.net/Articles/224135/).
  109. To avoid this kind of situation, ensure that all patches within a given
  110. branch stick closely to the associated topic; a "driver fixes" branch
  111. should not be making changes to the core memory management code. And, most
  112. importantly, do not use a git tree to bypass the review process. Post an
  113. occasional summary of the tree to the relevant list, and, when the time is
  114. right, request that the tree be included in linux-next.
  115. If and when others start to send patches for inclusion into your tree,
  116. don't forget to review them. Also ensure that you maintain the correct
  117. authorship information; the git "am" tool does its best in this regard, but
  118. you may have to add a "From:" line to the patch if it has been relayed to
  119. you via a third party.
  120. When requesting a pull, be sure to give all the relevant information: where
  121. your tree is, what branch to pull, and what changes will result from the
  122. pull. The git request-pull command can be helpful in this regard; it will
  123. format the request as other developers expect, and will also check to be
  124. sure that you have remembered to push those changes to the public server.
  125. Reviewing patches
  126. -----------------
  127. Some readers will certainly object to putting this section with "advanced
  128. topics" on the grounds that even beginning kernel developers should be
  129. reviewing patches. It is certainly true that there is no better way to
  130. learn how to program in the kernel environment than by looking at code
  131. posted by others. In addition, reviewers are forever in short supply; by
  132. looking at code you can make a significant contribution to the process as a
  133. whole.
  134. Reviewing code can be an intimidating prospect, especially for a new kernel
  135. developer who may well feel nervous about questioning code - in public -
  136. which has been posted by those with more experience. Even code written by
  137. the most experienced developers can be improved, though. Perhaps the best
  138. piece of advice for reviewers (all reviewers) is this: phrase review
  139. comments as questions rather than criticisms. Asking "how does the lock
  140. get released in this path?" will always work better than stating "the
  141. locking here is wrong."
  142. Different developers will review code from different points of view. Some
  143. are mostly concerned with coding style and whether code lines have trailing
  144. white space. Others will focus primarily on whether the change implemented
  145. by the patch as a whole is a good thing for the kernel or not. Yet others
  146. will check for problematic locking, excessive stack usage, possible
  147. security issues, duplication of code found elsewhere, adequate
  148. documentation, adverse effects on performance, user-space ABI changes, etc.
  149. All types of review, if they lead to better code going into the kernel, are
  150. welcome and worthwhile.