Documentation/process/deprecated.rst

   1 .. SPDX-License-Identifier: GPL-2.0
   2
   3 .. _deprecated:
   4
   5 =====================================================================
   6 Deprecated Interfaces, Language Features, Attributes, and Conventions
   7 =====================================================================
   8
   9 In a perfect world, it would be possible to convert all instances of
  10 some deprecated API into the new API and entirely remove the old API in
  11 a single development cycle. However, due to the size of the kernel, the
  12 maintainership hierarchy, and timing, it's not always feasible to do these
  13 kinds of conversions at once. This means that new instances may sneak into
  14 the kernel while old ones are being removed, only making the amount of
  15 work to remove the API grow. In order to educate developers about what
  16 has been deprecated and why, this list has been created as a place to
  17 point when uses of deprecated things are proposed for inclusion in the
  18 kernel.
  19
  20 __deprecated
  21 ------------
  22 While this attribute does visually mark an interface as deprecated,
  23 it `does not produce warnings during builds any more
  24 <https://git.kernel.org/linus/771c035372a036f83353eef46dbb829780330234>`_
  25 because one of the standing goals of the kernel is to build without
  26 warnings and no one was actually doing anything to remove these deprecated
  27 interfaces. While using `__deprecated` is nice to note an old API in
  28 a header file, it isn't the full solution. Such interfaces must either
  29 be fully removed from the kernel, or added to this file to discourage
  30 others from using them in the future.
  31
  32 BUG() and BUG_ON()
  33 ------------------
  34 Use WARN() and WARN_ON() instead, and handle the "impossible"
  35 error condition as gracefully as possible. While the BUG()-family
  36 of APIs were originally designed to act as an "impossible situation"
  37 assert and to kill a kernel thread "safely", they turn out to just be
  38 too risky. (e.g. "In what order do locks need to be released? Have
  39 various states been restored?") Very commonly, using BUG() will
  40 destabilize a system or entirely break it, which makes it impossible
  41 to debug or even get viable crash reports. Linus has `very strong
  42 <https://lore.kernel.org/lkml/CA+55aFy6jNLsywVYdGp83AMrXBo_P-pkjkphPGrO=82SPKCpLQ@mail.gmail.com/>`_
  43 feelings `about this
  44 <https://lore.kernel.org/lkml/CAHk-=whDHsbK3HTOpTF=ue_o04onRwTEaK_ZoJp_fjbqq4+=Jw@mail.gmail.com/>`_.
  45
  46 Note that the WARN()-family should only be used for "expected to
  47 be unreachable" situations. If you want to warn about "reachable
  48 but undesirable" situations, please use the pr_warn()-family of
  49 functions. System owners may have set the *panic_on_warn* sysctl,
  50 to make sure their systems do not continue running in the face of
  51 "unreachable" conditions. (For example, see commits like `this one
  52 <https://git.kernel.org/linus/d4689846881d160a4d12a514e991a740bcb5d65a>`_.)
  53
  54 open-coded arithmetic in allocator arguments
  55 --------------------------------------------
  56 Dynamic size calculations (especially multiplication) should not be
  57 performed in memory allocator (or similar) function arguments due to the
  58 risk of them overflowing. This could lead to values wrapping around and a
  59 smaller allocation being made than the caller was expecting. Using those
  60 allocations could lead to linear overflows of heap memory and other
  61 misbehaviors. (One exception to this is literal values where the compiler
  62 can warn if they might overflow. Though using literals for arguments as
  63 suggested below is also harmless.)
  64
  65 For example, do not use ``count * size`` as an argument, as in::
  66
  67         foo = kmalloc(count * size, GFP_KERNEL);
  68
  69 Instead, the 2-factor form of the allocator should be used::
  70
  71         foo = kmalloc_array(count, size, GFP_KERNEL);
  72
  73 If no 2-factor form is available, the saturate-on-overflow helpers should
  74 be used::
  75
  76         bar = vmalloc(array_size(count, size));
  77
  78 Another common case to avoid is calculating the size of a structure with
  79 a trailing array of others structures, as in::
  80
  81         header = kzalloc(sizeof(*header) + count * sizeof(*header->item),
  82                          GFP_KERNEL);
  83
  84 Instead, use the helper::
  85
  86         header = kzalloc(struct_size(header, item, count), GFP_KERNEL);
  87
  88 See array_size(), array3_size(), and struct_size(),
  89 for more details as well as the related check_add_overflow() and
  90 check_mul_overflow() family of functions.
  91
  92 simple_strtol(), simple_strtoll(), simple_strtoul(), simple_strtoull()
  93 ----------------------------------------------------------------------
  94 The simple_strtol(), simple_strtoll(),
  95 simple_strtoul(), and simple_strtoull() functions
  96 explicitly ignore overflows, which may lead to unexpected results
  97 in callers. The respective kstrtol(), kstrtoll(),
  98 kstrtoul(), and kstrtoull() functions tend to be the
  99 correct replacements, though note that those require the string to be
 100 NUL or newline terminated.
 101
 102 strcpy()
 103 --------
 104 strcpy() performs no bounds checking on the destination
 105 buffer. This could result in linear overflows beyond the
 106 end of the buffer, leading to all kinds of misbehaviors. While
 107 `CONFIG_FORTIFY_SOURCE=y` and various compiler flags help reduce the
 108 risk of using this function, there is no good reason to add new uses of
 109 this function. The safe replacement is strscpy().
 110
 111 strncpy() on NUL-terminated strings
 112 -----------------------------------
 113 Use of strncpy() does not guarantee that the destination buffer
 114 will be NUL terminated. This can lead to various linear read overflows
 115 and other misbehavior due to the missing termination. It also NUL-pads the
 116 destination buffer if the source contents are shorter than the destination
 117 buffer size, which may be a needless performance penalty for callers using
 118 only NUL-terminated strings. The safe replacement is strscpy().
 119 (Users of strscpy() still needing NUL-padding should instead
 120 use strscpy_pad().)
 121
 122 If a caller is using non-NUL-terminated strings, strncpy()() can
 123 still be used, but destinations should be marked with the `__nonstring
 124 <https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html>`_
 125 attribute to avoid future compiler warnings.
 126
 127 strlcpy()
 128 ---------
 129 strlcpy() reads the entire source buffer first, possibly exceeding
 130 the given limit of bytes to copy. This is inefficient and can lead to
 131 linear read overflows if a source string is not NUL-terminated. The
 132 safe replacement is strscpy().
 133
 134 %p format specifier
 135 -------------------
 136 Traditionally, using "%p" in format strings would lead to regular address
 137 exposure flaws in dmesg, proc, sysfs, etc. Instead of leaving these to
 138 be exploitable, all "%p" uses in the kernel are being printed as a hashed
 139 value, rendering them unusable for addressing. New uses of "%p" should not
 140 be added to the kernel. For text addresses, using "%pS" is likely better,
 141 as it produces the more useful symbol name instead. For nearly everything
 142 else, just do not add "%p" at all.
 143
 144 Paraphrasing Linus's current `guidance <https://lore.kernel.org/lkml/CA+55aFwQEd_d40g4mUCSsVRZzrFPUJt74vc6PPpb675hYNXcKw@mail.gmail.com/>`_:
 145
 146 - If the hashed "%p" value is pointless, ask yourself whether the pointer
 147   itself is important. Maybe it should be removed entirely?
 148 - If you really think the true pointer value is important, why is some
 149   system state or user privilege level considered "special"? If you think
 150   you can justify it (in comments and commit log) well enough to stand
 151   up to Linus's scrutiny, maybe you can use "%px", along with making sure
 152   you have sensible permissions.
 153
 154 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/>`_.
 155
 156 Variable Length Arrays (VLAs)
 157 -----------------------------
 158 Using stack VLAs produces much worse machine code than statically
 159 sized stack arrays. While these non-trivial `performance issues
 160 <https://git.kernel.org/linus/02361bc77888>`_ are reason enough to
 161 eliminate VLAs, they are also a security risk. Dynamic growth of a stack
 162 array may exceed the remaining memory in the stack segment. This could
 163 lead to a crash, possible overwriting sensitive contents at the end of the
 164 stack (when built without `CONFIG_THREAD_INFO_IN_TASK=y`), or overwriting
 165 memory adjacent to the stack (when built without `CONFIG_VMAP_STACK=y`)
 166
 167 Implicit switch case fall-through
 168 ---------------------------------
 169 The C language allows switch cases to fall through to the next case
 170 when a "break" statement is missing at the end of a case. This, however,
 171 introduces ambiguity in the code, as it's not always clear if the missing
 172 break is intentional or a bug. For example, it's not obvious just from
 173 looking at the code if `STATE_ONE` is intentionally designed to fall
 174 through into `STATE_TWO`::
 175
 176         switch (value) {
 177         case STATE_ONE:
 178                 do_something();
 179         case STATE_TWO:
 180                 do_other();
 181                 break;
 182         default:
 183                 WARN("unknown state");
 184         }
 185
 186 As there have been a long list of flaws `due to missing "break" statements
 187 <https://cwe.mitre.org/data/definitions/484.html>`_, we no longer allow
 188 implicit fall-through. In order to identify intentional fall-through
 189 cases, we have adopted a pseudo-keyword macro "fallthrough" which
 190 expands to gcc's extension `__attribute__((__fallthrough__))
 191 <https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html>`_.
 192 (When the C17/C18  `[[fallthrough]]` syntax is more commonly supported by
 193 C compilers, static analyzers, and IDEs, we can switch to using that syntax
 194 for the macro pseudo-keyword.)
 195
 196 All switch/case blocks must end in one of:
 197
 198 * break;
 199 * fallthrough;
 200 * continue;
 201 * goto <label>;
 202 * return [expression];