deprecated.rst 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328
  1. .. SPDX-License-Identifier: GPL-2.0
  2. .. _deprecated:
  3. =====================================================================
  4. Deprecated Interfaces, Language Features, Attributes, and Conventions
  5. =====================================================================
  6. In a perfect world, it would be possible to convert all instances of
  7. some deprecated API into the new API and entirely remove the old API in
  8. a single development cycle. However, due to the size of the kernel, the
  9. maintainership hierarchy, and timing, it's not always feasible to do these
  10. kinds of conversions at once. This means that new instances may sneak into
  11. the kernel while old ones are being removed, only making the amount of
  12. work to remove the API grow. In order to educate developers about what
  13. has been deprecated and why, this list has been created as a place to
  14. point when uses of deprecated things are proposed for inclusion in the
  15. kernel.
  16. __deprecated
  17. ------------
  18. While this attribute does visually mark an interface as deprecated,
  19. it `does not produce warnings during builds any more
  20. <https://git.kernel.org/linus/771c035372a036f83353eef46dbb829780330234>`_
  21. because one of the standing goals of the kernel is to build without
  22. warnings and no one was actually doing anything to remove these deprecated
  23. interfaces. While using `__deprecated` is nice to note an old API in
  24. a header file, it isn't the full solution. Such interfaces must either
  25. be fully removed from the kernel, or added to this file to discourage
  26. others from using them in the future.
  27. BUG() and BUG_ON()
  28. ------------------
  29. Use WARN() and WARN_ON() instead, and handle the "impossible"
  30. error condition as gracefully as possible. While the BUG()-family
  31. of APIs were originally designed to act as an "impossible situation"
  32. assert and to kill a kernel thread "safely", they turn out to just be
  33. too risky. (e.g. "In what order do locks need to be released? Have
  34. various states been restored?") Very commonly, using BUG() will
  35. destabilize a system or entirely break it, which makes it impossible
  36. to debug or even get viable crash reports. Linus has `very strong
  37. <https://lore.kernel.org/lkml/CA+55aFy6jNLsywVYdGp83AMrXBo_P-pkjkphPGrO=82SPKCpLQ@mail.gmail.com/>`_
  38. feelings `about this
  39. <https://lore.kernel.org/lkml/CAHk-=whDHsbK3HTOpTF=ue_o04onRwTEaK_ZoJp_fjbqq4+=Jw@mail.gmail.com/>`_.
  40. Note that the WARN()-family should only be used for "expected to
  41. be unreachable" situations. If you want to warn about "reachable
  42. but undesirable" situations, please use the pr_warn()-family of
  43. functions. System owners may have set the *panic_on_warn* sysctl,
  44. to make sure their systems do not continue running in the face of
  45. "unreachable" conditions. (For example, see commits like `this one
  46. <https://git.kernel.org/linus/d4689846881d160a4d12a514e991a740bcb5d65a>`_.)
  47. open-coded arithmetic in allocator arguments
  48. --------------------------------------------
  49. Dynamic size calculations (especially multiplication) should not be
  50. performed in memory allocator (or similar) function arguments due to the
  51. risk of them overflowing. This could lead to values wrapping around and a
  52. smaller allocation being made than the caller was expecting. Using those
  53. allocations could lead to linear overflows of heap memory and other
  54. misbehaviors. (One exception to this is literal values where the compiler
  55. can warn if they might overflow. Though using literals for arguments as
  56. suggested below is also harmless.)
  57. For example, do not use ``count * size`` as an argument, as in::
  58. foo = kmalloc(count * size, GFP_KERNEL);
  59. Instead, the 2-factor form of the allocator should be used::
  60. foo = kmalloc_array(count, size, GFP_KERNEL);
  61. If no 2-factor form is available, the saturate-on-overflow helpers should
  62. be used::
  63. bar = vmalloc(array_size(count, size));
  64. Another common case to avoid is calculating the size of a structure with
  65. a trailing array of others structures, as in::
  66. header = kzalloc(sizeof(*header) + count * sizeof(*header->item),
  67. GFP_KERNEL);
  68. Instead, use the helper::
  69. header = kzalloc(struct_size(header, item, count), GFP_KERNEL);
  70. .. note:: If you are using struct_size() on a structure containing a zero-length
  71. or a one-element array as a trailing array member, please refactor such
  72. array usage and switch to a `flexible array member
  73. <#zero-length-and-one-element-arrays>`_ instead.
  74. See array_size(), array3_size(), and struct_size(),
  75. for more details as well as the related check_add_overflow() and
  76. check_mul_overflow() family of functions.
  77. simple_strtol(), simple_strtoll(), simple_strtoul(), simple_strtoull()
  78. ----------------------------------------------------------------------
  79. The simple_strtol(), simple_strtoll(),
  80. simple_strtoul(), and simple_strtoull() functions
  81. explicitly ignore overflows, which may lead to unexpected results
  82. in callers. The respective kstrtol(), kstrtoll(),
  83. kstrtoul(), and kstrtoull() functions tend to be the
  84. correct replacements, though note that those require the string to be
  85. NUL or newline terminated.
  86. strcpy()
  87. --------
  88. strcpy() performs no bounds checking on the destination buffer. This
  89. could result in linear overflows beyond the end of the buffer, leading to
  90. all kinds of misbehaviors. While `CONFIG_FORTIFY_SOURCE=y` and various
  91. compiler flags help reduce the risk of using this function, there is
  92. no good reason to add new uses of this function. The safe replacement
  93. is strscpy(), though care must be given to any cases where the return
  94. value of strcpy() was used, since strscpy() does not return a pointer to
  95. the destination, but rather a count of non-NUL bytes copied (or negative
  96. errno when it truncates).
  97. strncpy() on NUL-terminated strings
  98. -----------------------------------
  99. Use of strncpy() does not guarantee that the destination buffer will
  100. be NUL terminated. This can lead to various linear read overflows and
  101. other misbehavior due to the missing termination. It also NUL-pads
  102. the destination buffer if the source contents are shorter than the
  103. destination buffer size, which may be a needless performance penalty
  104. for callers using only NUL-terminated strings. The safe replacement is
  105. strscpy(), though care must be given to any cases where the return value
  106. of strncpy() was used, since strscpy() does not return a pointer to the
  107. destination, but rather a count of non-NUL bytes copied (or negative
  108. errno when it truncates). Any cases still needing NUL-padding should
  109. instead use strscpy_pad().
  110. If a caller is using non-NUL-terminated strings, strncpy() can
  111. still be used, but destinations should be marked with the `__nonstring
  112. <https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html>`_
  113. attribute to avoid future compiler warnings.
  114. strlcpy()
  115. ---------
  116. strlcpy() reads the entire source buffer first (since the return value
  117. is meant to match that of strlen()). This read may exceed the destination
  118. size limit. This is both inefficient and can lead to linear read overflows
  119. if a source string is not NUL-terminated. The safe replacement is strscpy(),
  120. though care must be given to any cases where the return value of strlcpy()
  121. is used, since strscpy() will return negative errno values when it truncates.
  122. %p format specifier
  123. -------------------
  124. Traditionally, using "%p" in format strings would lead to regular address
  125. exposure flaws in dmesg, proc, sysfs, etc. Instead of leaving these to
  126. be exploitable, all "%p" uses in the kernel are being printed as a hashed
  127. value, rendering them unusable for addressing. New uses of "%p" should not
  128. be added to the kernel. For text addresses, using "%pS" is likely better,
  129. as it produces the more useful symbol name instead. For nearly everything
  130. else, just do not add "%p" at all.
  131. Paraphrasing Linus's current `guidance <https://lore.kernel.org/lkml/CA+55aFwQEd_d40g4mUCSsVRZzrFPUJt74vc6PPpb675hYNXcKw@mail.gmail.com/>`_:
  132. - If the hashed "%p" value is pointless, ask yourself whether the pointer
  133. itself is important. Maybe it should be removed entirely?
  134. - If you really think the true pointer value is important, why is some
  135. system state or user privilege level considered "special"? If you think
  136. you can justify it (in comments and commit log) well enough to stand
  137. up to Linus's scrutiny, maybe you can use "%px", along with making sure
  138. you have sensible permissions.
  139. And finally, know that a toggle for "%p" hashing will `not be accepted <https://lore.kernel.org/lkml/CA+55aFwieC1-nAs+NFq9RTwaR8ef9hWa4MjNBWL41F-8wM49eA@mail.gmail.com/>`_.
  140. Variable Length Arrays (VLAs)
  141. -----------------------------
  142. Using stack VLAs produces much worse machine code than statically
  143. sized stack arrays. While these non-trivial `performance issues
  144. <https://git.kernel.org/linus/02361bc77888>`_ are reason enough to
  145. eliminate VLAs, they are also a security risk. Dynamic growth of a stack
  146. array may exceed the remaining memory in the stack segment. This could
  147. lead to a crash, possible overwriting sensitive contents at the end of the
  148. stack (when built without `CONFIG_THREAD_INFO_IN_TASK=y`), or overwriting
  149. memory adjacent to the stack (when built without `CONFIG_VMAP_STACK=y`)
  150. Implicit switch case fall-through
  151. ---------------------------------
  152. The C language allows switch cases to fall through to the next case
  153. when a "break" statement is missing at the end of a case. This, however,
  154. introduces ambiguity in the code, as it's not always clear if the missing
  155. break is intentional or a bug. For example, it's not obvious just from
  156. looking at the code if `STATE_ONE` is intentionally designed to fall
  157. through into `STATE_TWO`::
  158. switch (value) {
  159. case STATE_ONE:
  160. do_something();
  161. case STATE_TWO:
  162. do_other();
  163. break;
  164. default:
  165. WARN("unknown state");
  166. }
  167. As there have been a long list of flaws `due to missing "break" statements
  168. <https://cwe.mitre.org/data/definitions/484.html>`_, we no longer allow
  169. implicit fall-through. In order to identify intentional fall-through
  170. cases, we have adopted a pseudo-keyword macro "fallthrough" which
  171. expands to gcc's extension `__attribute__((__fallthrough__))
  172. <https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html>`_.
  173. (When the C17/C18 `[[fallthrough]]` syntax is more commonly supported by
  174. C compilers, static analyzers, and IDEs, we can switch to using that syntax
  175. for the macro pseudo-keyword.)
  176. All switch/case blocks must end in one of:
  177. * break;
  178. * fallthrough;
  179. * continue;
  180. * goto <label>;
  181. * return [expression];
  182. Zero-length and one-element arrays
  183. ----------------------------------
  184. There is a regular need in the kernel to provide a way to declare having
  185. a dynamically sized set of trailing elements in a structure. Kernel code
  186. should always use `"flexible array members" <https://en.wikipedia.org/wiki/Flexible_array_member>`_
  187. for these cases. The older style of one-element or zero-length arrays should
  188. no longer be used.
  189. In older C code, dynamically sized trailing elements were done by specifying
  190. a one-element array at the end of a structure::
  191. struct something {
  192. size_t count;
  193. struct foo items[1];
  194. };
  195. This led to fragile size calculations via sizeof() (which would need to
  196. remove the size of the single trailing element to get a correct size of
  197. the "header"). A `GNU C extension <https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_
  198. was introduced to allow for zero-length arrays, to avoid these kinds of
  199. size problems::
  200. struct something {
  201. size_t count;
  202. struct foo items[0];
  203. };
  204. But this led to other problems, and didn't solve some problems shared by
  205. both styles, like not being able to detect when such an array is accidentally
  206. being used _not_ at the end of a structure (which could happen directly, or
  207. when such a struct was in unions, structs of structs, etc).
  208. C99 introduced "flexible array members", which lacks a numeric size for
  209. the array declaration entirely::
  210. struct something {
  211. size_t count;
  212. struct foo items[];
  213. };
  214. This is the way the kernel expects dynamically sized trailing elements
  215. to be declared. It allows the compiler to generate errors when the
  216. flexible array does not occur last in the structure, which helps to prevent
  217. some kind of `undefined behavior
  218. <https://git.kernel.org/linus/76497732932f15e7323dc805e8ea8dc11bb587cf>`_
  219. bugs from being inadvertently introduced to the codebase. It also allows
  220. the compiler to correctly analyze array sizes (via sizeof(),
  221. `CONFIG_FORTIFY_SOURCE`, and `CONFIG_UBSAN_BOUNDS`). For instance,
  222. there is no mechanism that warns us that the following application of the
  223. sizeof() operator to a zero-length array always results in zero::
  224. struct something {
  225. size_t count;
  226. struct foo items[0];
  227. };
  228. struct something *instance;
  229. instance = kmalloc(struct_size(instance, items, count), GFP_KERNEL);
  230. instance->count = count;
  231. size = sizeof(instance->items) * instance->count;
  232. memcpy(instance->items, source, size);
  233. At the last line of code above, ``size`` turns out to be ``zero``, when one might
  234. have thought it represents the total size in bytes of the dynamic memory recently
  235. allocated for the trailing array ``items``. Here are a couple examples of this
  236. issue: `link 1
  237. <https://git.kernel.org/linus/f2cd32a443da694ac4e28fbf4ac6f9d5cc63a539>`_,
  238. `link 2
  239. <https://git.kernel.org/linus/ab91c2a89f86be2898cee208d492816ec238b2cf>`_.
  240. Instead, `flexible array members have incomplete type, and so the sizeof()
  241. operator may not be applied <https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_,
  242. so any misuse of such operators will be immediately noticed at build time.
  243. With respect to one-element arrays, one has to be acutely aware that `such arrays
  244. occupy at least as much space as a single object of the type
  245. <https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_,
  246. hence they contribute to the size of the enclosing structure. This is prone
  247. to error every time people want to calculate the total size of dynamic memory
  248. to allocate for a structure containing an array of this kind as a member::
  249. struct something {
  250. size_t count;
  251. struct foo items[1];
  252. };
  253. struct something *instance;
  254. instance = kmalloc(struct_size(instance, items, count - 1), GFP_KERNEL);
  255. instance->count = count;
  256. size = sizeof(instance->items) * instance->count;
  257. memcpy(instance->items, source, size);
  258. In the example above, we had to remember to calculate ``count - 1`` when using
  259. the struct_size() helper, otherwise we would have --unintentionally-- allocated
  260. memory for one too many ``items`` objects. The cleanest and least error-prone way
  261. to implement this is through the use of a `flexible array member`, together with
  262. struct_size() and flex_array_size() helpers::
  263. struct something {
  264. size_t count;
  265. struct foo items[];
  266. };
  267. struct something *instance;
  268. instance = kmalloc(struct_size(instance, items, count), GFP_KERNEL);
  269. instance->count = count;
  270. memcpy(instance->items, source, flex_array_size(instance, items, instance->count));