.. SPDX-License-Identifier: GPL-2.0 .. _deprecated: =====================================================================Deprecated Interfaces, Language Features, Attributes, and Conventions===================================================================== In a perfect world, it would be possible to convert all instances ofsome deprecated API into the new API and entirely remove the old API ina single development cycle. However, due to the size of the kernel, themaintainership hierarchy, and timing, it's not always feasible to do thesekinds of conversions at once. This means that new instances may sneak intothe kernel while old ones are being removed, only making the amount ofwork to remove the API grow. In order to educate developers about whathas been deprecated and why, this list has been created as a place topoint when uses of deprecated things are proposed for inclusion in thekernel. __deprecated------------While this attribute does visually mark an interface as deprecated,it `does not produce warnings during builds any more<https://git.kernel.org/linus/771c035372a036f83353eef46dbb829780330234>`_because one of the standing goals of the kernel is to build withoutwarnings and no one was actually doing anything to remove these deprecatedinterfaces. While using `__deprecated` is nice to note an old API ina header file, it isn't the full solution. Such interfaces must eitherbe fully removed from the kernel, or added to this file to discourageothers from using them in the future. BUG() and BUG_ON()------------------Use WARN() and WARN_ON() instead, and handle the "impossible"error condition as gracefully as possible. While the BUG()-familyof APIs were originally designed to act as an "impossible situation"assert and to kill a kernel thread "safely", they turn out to just betoo risky. (e.g. "In what order do locks need to be released? Havevarious states been restored?") Very commonly, using BUG() willdestabilize a system or entirely break it, which makes it impossibleto debug or even get viable crash reports. Linus has `very strong<https://lore.kernel.org/lkml/CA+55aFy6jNLsywVYdGp83AMrXBo_P-pkjkphPGrO=82SPKCpLQ@mail.gmail.com/>`_feelings `about this<https://lore.kernel.org/lkml/CAHk-=whDHsbK3HTOpTF=ue_o04onRwTEaK_ZoJp_fjbqq4+=Jw@mail.gmail.com/>`_. Note that the WARN()-family should only be used for "expected tobe unreachable" situations. If you want to warn about "reachablebut undesirable" situations, please use the pr_warn()-family offunctions. System owners may have set the *panic_on_warn* sysctl,to make sure their systems do not continue running in the face of"unreachable" conditions. (For example, see commits like `this one<https://git.kernel.org/linus/d4689846881d160a4d12a514e991a740bcb5d65a>`_.) open-coded arithmetic in allocator arguments--------------------------------------------Dynamic size calculations (especially multiplication) should not beperformed in memory allocator (or similar) function arguments due to therisk of them overflowing. This could lead to values wrapping around and asmaller allocation being made than the caller was expecting. Using thoseallocations could lead to linear overflows of heap memory and othermisbehaviors. (One exception to this is literal values where the compilercan warn if they might overflow. However, the preferred way in thesecases is to refactor the code as suggested below to avoid the open-codedarithmetic.) For example, do not use ``count * size`` as an argument, as in:: 	foo = kmalloc(count * size, GFP_KERNEL); Instead, the 2-factor form of the allocator should be used:: 	foo = kmalloc_array(count, size, GFP_KERNEL); Specifically, kmalloc() can be replaced with kmalloc_array(), andkzalloc() can be replaced with kcalloc(). If no 2-factor form is available, the saturate-on-overflow helpers shouldbe used:: 	bar = dma_alloc_coherent(dev, array_size(count, size), &dma, GFP_KERNEL); Another common case to avoid is calculating the size of a structure witha trailing array of others structures, as in:: 	header = kzalloc(sizeof(*header) + count * sizeof(*header->item),			 GFP_KERNEL); Instead, use the helper:: 	header = kzalloc(struct_size(header, item, count), GFP_KERNEL); .. note:: If you are using struct_size() on a structure containing a zero-length        or a one-element array as a trailing array member, please refactor such        array usage and switch to a `flexible array member        <#zero-length-and-one-element-arrays>`_ instead. For other calculations, please compose the use of the size_mul(),size_add(), and size_sub() helpers. For example, in the case of:: 	foo = krealloc(current_size + chunk_size * (count - 3), GFP_KERNEL); Instead, use the helpers:: 	foo = krealloc(size_add(current_size,				size_mul(chunk_size,					 size_sub(count, 3))), GFP_KERNEL); For more details, also see array3_size() and flex_array_size(),as well as the related check_mul_overflow(), check_add_overflow(),check_sub_overflow(), and check_shl_overflow() family of functions. simple_strtol(), simple_strtoll(), simple_strtoul(), simple_strtoull()----------------------------------------------------------------------The simple_strtol(), simple_strtoll(),simple_strtoul(), and simple_strtoull() functionsexplicitly ignore overflows, which may lead to unexpected resultsin callers. The respective kstrtol(), kstrtoll(),kstrtoul(), and kstrtoull() functions tend to be thecorrect replacements, though note that those require the string to beNUL or newline terminated. strcpy()--------strcpy() performs no bounds checking on the destination buffer. Thiscould result in linear overflows beyond the end of the buffer, leading toall kinds of misbehaviors. While `CONFIG_FORTIFY_SOURCE=y` and variouscompiler flags help reduce the risk of using this function, there isno good reason to add new uses of this function. The safe replacementis strscpy(), though care must be given to any cases where the returnvalue of strcpy() was used, since strscpy() does not return a pointer tothe destination, but rather a count of non-NUL bytes copied (or negativeerrno when it truncates). strncpy()---------strncpy() has been removed from the kernel. All former callers havebeen migrated to safer alternatives. strncpy() did not guarantee NUL-termination of the destination buffer,leading to linear read overflows and other misbehavior. It alsounconditionally NUL-padded the destination, which was a needlessperformance penalty for callers using only NUL-terminated strings. Dueto its various behaviors, it was an ambiguous API for determining whatan author's true intent was for the copy. The replacements for strncpy() are: - strscpy() when the destination must be NUL-terminated.- strscpy_pad() when the destination must be NUL-terminated and  zero-padded (e.g., structs crossing privilege boundaries).- memtostr() for NUL-terminated destinations from non-NUL-terminated  fixed-width sources (with the `__nonstring` attribute on the source).- memtostr_pad() for the same, but with zero-padding.- strtomem() for non-NUL-terminated fixed-width destinations, with  the `__nonstring` attribute on the destination.- strtomem_pad() for non-NUL-terminated destinations that also need  zero-padding.- memcpy_and_pad() for bounded copies from potentially unterminated  sources where the destination size is a runtime value. strlcpy()---------strlcpy() reads the entire source buffer first (since the return valueis meant to match that of strlen()). This read may exceed the destinationsize limit. This is both inefficient and can lead to linear read overflowsif a source string is not NUL-terminated. The safe replacement is strscpy(),though care must be given to any cases where the return value of strlcpy()is used, since strscpy() will return negative errno values when it truncates. %p format specifier-------------------Traditionally, using "%p" in format strings would lead to regular addressexposure flaws in dmesg, proc, sysfs, etc. Instead of leaving these tobe exploitable, all "%p" uses in the kernel are being printed as a hashedvalue, rendering them unusable for addressing. New uses of "%p" should notbe added to the kernel. For text addresses, using "%pS" is likely better,as it produces the more useful symbol name instead. For nearly everythingelse, just do not add "%p" at all. Paraphrasing Linus's current `guidance <https://lore.kernel.org/lkml/CA+55aFwQEd_d40g4mUCSsVRZzrFPUJt74vc6PPpb675hYNXcKw@mail.gmail.com/>`_: - If the hashed "%p" value is pointless, ask yourself whether the pointer  itself is important. Maybe it should be removed entirely?- If you really think the true pointer value is important, why is some  system state or user privilege level considered "special"? If you think  you can justify it (in comments and commit log) well enough to stand  up to Linus's scrutiny, maybe you can use "%px", along with making sure  you have sensible permissions. If you are debugging something where "%p" hashing is causing problems,you can temporarily boot with the debug flag "`no_hash_pointers<https://git.kernel.org/linus/5ead723a20e0447bc7db33dc3070b420e5f80aa6>`_". Variable Length Arrays (VLAs)-----------------------------Using stack VLAs produces much worse machine code than staticallysized stack arrays. While these non-trivial `performance issues<https://git.kernel.org/linus/02361bc77888>`_ are reason enough toeliminate VLAs, they are also a security risk. Dynamic growth of a stackarray may exceed the remaining memory in the stack segment. This couldlead to a crash, possible overwriting sensitive contents at the end of thestack (when built without `CONFIG_THREAD_INFO_IN_TASK=y`), or overwritingmemory adjacent to the stack (when built without `CONFIG_VMAP_STACK=y`) Implicit switch case fall-through---------------------------------The C language allows switch cases to fall through to the next casewhen a "break" statement is missing at the end of a case. This, however,introduces ambiguity in the code, as it's not always clear if the missingbreak is intentional or a bug. For example, it's not obvious just fromlooking at the code if `STATE_ONE` is intentionally designed to fallthrough into `STATE_TWO`:: 	switch (value) {	case STATE_ONE:		do_something();	case STATE_TWO:		do_other();		break;	default:		WARN("unknown state");	} As there have been a long list of flaws `due to missing "break" statements<https://cwe.mitre.org/data/definitions/484.html>`_, we no longer allowimplicit fall-through. In order to identify intentional fall-throughcases, we have adopted a pseudo-keyword macro "fallthrough" whichexpands to gcc's extension `__attribute__((__fallthrough__))<https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html>`_.(When the C17/C18  `[[fallthrough]]` syntax is more commonly supported byC compilers, static analyzers, and IDEs, we can switch to using that syntaxfor the macro pseudo-keyword.) All switch/case blocks must end in one of: * break;* fallthrough;* continue;* goto <label>;* return [expression]; Zero-length and one-element arrays----------------------------------There is a regular need in the kernel to provide a way to declare havinga dynamically sized set of trailing elements in a structure. Kernel codeshould always use `"flexible array members" <https://en.wikipedia.org/wiki/Flexible_array_member>`_for these cases. The older style of one-element or zero-length arrays shouldno longer be used. In older C code, dynamically sized trailing elements were done by specifyinga one-element array at the end of a structure::         struct something {                size_t count;                struct foo items[1];        }; This led to fragile size calculations via sizeof() (which would need toremove the size of the single trailing element to get a correct size ofthe "header"). A `GNU C extension <https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_was introduced to allow for zero-length arrays, to avoid these kinds ofsize problems::         struct something {                size_t count;                struct foo items[0];        }; But this led to other problems, and didn't solve some problems shared byboth styles, like not being able to detect when such an array is accidentallybeing used _not_ at the end of a structure (which could happen directly, orwhen such a struct was in unions, structs of structs, etc). C99 introduced "flexible array members", which lacks a numeric size forthe array declaration entirely::         struct something {                size_t count;                struct foo items[];        }; This is the way the kernel expects dynamically sized trailing elementsto be declared. It allows the compiler to generate errors when theflexible array does not occur last in the structure, which helps to preventsome kind of `undefined behavior<https://git.kernel.org/linus/76497732932f15e7323dc805e8ea8dc11bb587cf>`_bugs from being inadvertently introduced to the codebase. It also allowsthe compiler to correctly analyze array sizes (via sizeof(),`CONFIG_FORTIFY_SOURCE`, and `CONFIG_UBSAN_BOUNDS`). For instance,there is no mechanism that warns us that the following application of thesizeof() operator to a zero-length array always results in zero::         struct something {                size_t count;                struct foo items[0];        };         struct something *instance;         instance = kmalloc(struct_size(instance, items, count), GFP_KERNEL);        instance->count = count;         size = sizeof(instance->items) * instance->count;        memcpy(instance->items, source, size); At the last line of code above, ``size`` turns out to be ``zero``, when one mighthave thought it represents the total size in bytes of the dynamic memory recentlyallocated for the trailing array ``items``. Here are a couple examples of thisissue: `link 1<https://git.kernel.org/linus/f2cd32a443da694ac4e28fbf4ac6f9d5cc63a539>`_,`link 2<https://git.kernel.org/linus/ab91c2a89f86be2898cee208d492816ec238b2cf>`_.Instead, `flexible array members have incomplete type, and so the sizeof()operator may not be applied <https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_,so any misuse of such operators will be immediately noticed at build time. With respect to one-element arrays, one has to be acutely aware that `such arraysoccupy at least as much space as a single object of the type<https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html>`_,hence they contribute to the size of the enclosing structure. This is proneto error every time people want to calculate the total size of dynamic memoryto allocate for a structure containing an array of this kind as a member::         struct something {                size_t count;                struct foo items[1];        };         struct something *instance;         instance = kmalloc(struct_size(instance, items, count - 1), GFP_KERNEL);        instance->count = count;         size = sizeof(instance->items) * instance->count;        memcpy(instance->items, source, size); In the example above, we had to remember to calculate ``count - 1`` when usingthe struct_size() helper, otherwise we would have --unintentionally-- allocatedmemory for one too many ``items`` objects. The cleanest and least error-prone wayto implement this is through the use of a `flexible array member`, together withstruct_size() and flex_array_size() helpers::         struct something {                size_t count;                struct foo items[];        };         struct something *instance;         instance = kmalloc(struct_size(instance, items, count), GFP_KERNEL);        instance->count = count;         memcpy(instance->items, source, flex_array_size(instance, items, instance->count)); There are two special cases of replacement where the DECLARE_FLEX_ARRAY()helper needs to be used. (Note that it is named __DECLARE_FLEX_ARRAY() foruse in UAPI headers.) Those cases are when the flexible array is eitheralone in a struct or is part of a union. These are disallowed by the C99specification, but for no technical reason (as can be seen by both theexisting use of such arrays in those places and the work-around thatDECLARE_FLEX_ARRAY() uses). For example, to convert this:: 	struct something {		...		union {			struct type1 one[0];			struct type2 two[0];		};	}; The helper must be used:: 	struct something {		...		union {			DECLARE_FLEX_ARRAY(struct type1, one);			DECLARE_FLEX_ARRAY(struct type2, two);		};	}; Open-coded kmalloc assignments for struct objects-------------------------------------------------Performing open-coded kmalloc()-family allocation assignments preventsthe kernel (and compiler) from being able to examine the type of thevariable being assigned, which limits any related introspection thatmay help with alignment, wrap-around, or additional hardening. Thekmalloc_obj()-family of macros provide this introspection, which can beused for the common code patterns for single, array, and flexible objectallocations. For example, these open coded assignments:: 	ptr = kmalloc(sizeof(*ptr), gfp);	ptr = kzalloc(sizeof(*ptr), gfp);	ptr = kmalloc_array(count, sizeof(*ptr), gfp);	ptr = kcalloc(count, sizeof(*ptr), gfp);	ptr = kmalloc(struct_size(ptr, flex_member, count), gfp);	ptr = kmalloc(sizeof(struct foo), gfp); become, respectively:: 	ptr = kmalloc_obj(*ptr [, gfp] );	ptr = kzalloc_obj(*ptr [, gfp] );	ptr = kmalloc_objs(*ptr, count [, gfp] );	ptr = kzalloc_objs(*ptr, count [, gfp] );	ptr = kmalloc_flex(*ptr, flex_member, count [, gfp] );	__auto_type ptr = kmalloc_obj(struct foo [, gfp] ); The argument gfp is optional, the default value is GFP_KERNEL.If `ptr->flex_member` is annotated with __counted_by(), the allocationwill automatically fail if `count` is larger than the maximumrepresentable value that can be stored in the counter member associatedwith `flex_member`.