License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2019-11-21 11:58:56 +00:00
|
|
|
/*
|
|
|
|
* Variant of atomic_t specialized for reference counts.
|
|
|
|
*
|
|
|
|
* The interface matches the atomic_t interface (to aid in porting) but only
|
|
|
|
* provides the few functions one should use for reference counting.
|
|
|
|
*
|
2019-11-21 11:58:57 +00:00
|
|
|
* Saturation semantics
|
|
|
|
* ====================
|
|
|
|
*
|
|
|
|
* refcount_t differs from atomic_t in that the counter saturates at
|
|
|
|
* REFCOUNT_SATURATED and will not move once there. This avoids wrapping the
|
|
|
|
* counter and causing 'spurious' use-after-free issues. In order to avoid the
|
|
|
|
* cost associated with introducing cmpxchg() loops into all of the saturating
|
|
|
|
* operations, we temporarily allow the counter to take on an unchecked value
|
|
|
|
* and then explicitly set it to REFCOUNT_SATURATED on detecting that underflow
|
|
|
|
* or overflow has occurred. Although this is racy when multiple threads
|
|
|
|
* access the refcount concurrently, by placing REFCOUNT_SATURATED roughly
|
|
|
|
* equidistant from 0 and INT_MAX we minimise the scope for error:
|
|
|
|
*
|
|
|
|
* INT_MAX REFCOUNT_SATURATED UINT_MAX
|
|
|
|
* 0 (0x7fff_ffff) (0xc000_0000) (0xffff_ffff)
|
|
|
|
* +--------------------------------+----------------+----------------+
|
|
|
|
* <---------- bad value! ---------->
|
|
|
|
*
|
|
|
|
* (in a signed view of the world, the "bad value" range corresponds to
|
|
|
|
* a negative counter value).
|
|
|
|
*
|
|
|
|
* As an example, consider a refcount_inc() operation that causes the counter
|
|
|
|
* to overflow:
|
|
|
|
*
|
|
|
|
* int old = atomic_fetch_add_relaxed(r);
|
|
|
|
* // old is INT_MAX, refcount now INT_MIN (0x8000_0000)
|
|
|
|
* if (old < 0)
|
|
|
|
* atomic_set(r, REFCOUNT_SATURATED);
|
|
|
|
*
|
|
|
|
* If another thread also performs a refcount_inc() operation between the two
|
|
|
|
* atomic operations, then the count will continue to edge closer to 0. If it
|
|
|
|
* reaches a value of 1 before /any/ of the threads reset it to the saturated
|
|
|
|
* value, then a concurrent refcount_dec_and_test() may erroneously free the
|
2020-03-03 10:54:27 +00:00
|
|
|
* underlying object.
|
|
|
|
* Linux limits the maximum number of tasks to PID_MAX_LIMIT, which is currently
|
|
|
|
* 0x400000 (and can't easily be raised in the future beyond FUTEX_TID_MASK).
|
|
|
|
* With the current PID limit, if no batched refcounting operations are used and
|
|
|
|
* the attacker can't repeatedly trigger kernel oopses in the middle of refcount
|
|
|
|
* operations, this makes it impossible for a saturated refcount to leave the
|
|
|
|
* saturation range, even if it is possible for multiple uses of the same
|
|
|
|
* refcount to nest in the context of a single task:
|
|
|
|
*
|
|
|
|
* (UINT_MAX+1-REFCOUNT_SATURATED) / PID_MAX_LIMIT =
|
|
|
|
* 0x40000000 / 0x400000 = 0x100 = 256
|
|
|
|
*
|
|
|
|
* If hundreds of references are added/removed with a single refcounting
|
|
|
|
* operation, it may potentially be possible to leave the saturation range; but
|
|
|
|
* given the precise timing details involved with the round-robin scheduling of
|
|
|
|
* each thread manipulating the refcount and the need to hit the race multiple
|
|
|
|
* times in succession, there doesn't appear to be a practical avenue of attack
|
|
|
|
* even if using refcount_add() operations with larger increments.
|
2019-11-21 11:58:57 +00:00
|
|
|
*
|
|
|
|
* Memory ordering
|
|
|
|
* ===============
|
2019-11-21 11:58:56 +00:00
|
|
|
*
|
|
|
|
* Memory ordering rules are slightly relaxed wrt regular atomic_t functions
|
|
|
|
* and provide only what is strictly required for refcounts.
|
|
|
|
*
|
|
|
|
* The increments are fully relaxed; these will not provide ordering. The
|
|
|
|
* rationale is that whatever is used to obtain the object we're increasing the
|
|
|
|
* reference count on will provide the ordering. For locked data structures,
|
|
|
|
* its the lock acquire, for RCU/lockless data structures its the dependent
|
|
|
|
* load.
|
|
|
|
*
|
|
|
|
* Do note that inc_not_zero() provides a control dependency which will order
|
|
|
|
* future stores against the inc, this ensures we'll never modify the object
|
|
|
|
* if we did not in fact acquire a reference.
|
|
|
|
*
|
|
|
|
* The decrements will provide release order, such that all the prior loads and
|
|
|
|
* stores will be issued before, it also provides a control dependency, which
|
|
|
|
* will order us against the subsequent free().
|
|
|
|
*
|
|
|
|
* The control dependency is against the load of the cmpxchg (ll/sc) that
|
|
|
|
* succeeded. This means the stores aren't fully ordered, but this is fine
|
|
|
|
* because the 1->0 transition indicates no concurrency.
|
|
|
|
*
|
|
|
|
* Note that the allocator is responsible for ordering things between free()
|
|
|
|
* and alloc().
|
|
|
|
*
|
|
|
|
* The decrements dec_and_test() and sub_and_test() also provide acquire
|
|
|
|
* ordering on success.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2019-11-21 11:59:00 +00:00
|
|
|
#ifndef _LINUX_REFCOUNT_H
|
|
|
|
#define _LINUX_REFCOUNT_H
|
|
|
|
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
#include <linux/bug.h>
|
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <linux/limits.h>
|
|
|
|
#include <linux/spinlock_types.h>
|
|
|
|
|
|
|
|
struct mutex;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct refcount_t - variant of atomic_t specialized for reference counts
|
|
|
|
* @refs: atomic_t counter field
|
|
|
|
*
|
|
|
|
* The counter saturates at REFCOUNT_SATURATED and will not move once
|
|
|
|
* there. This avoids wrapping the counter and causing 'spurious'
|
|
|
|
* use-after-free bugs.
|
|
|
|
*/
|
|
|
|
typedef struct refcount_struct {
|
|
|
|
atomic_t refs;
|
|
|
|
} refcount_t;
|
|
|
|
|
|
|
|
#define REFCOUNT_INIT(n) { .refs = ATOMIC_INIT(n), }
|
|
|
|
#define REFCOUNT_MAX INT_MAX
|
|
|
|
#define REFCOUNT_SATURATED (INT_MIN / 2)
|
|
|
|
|
|
|
|
enum refcount_saturation_type {
|
|
|
|
REFCOUNT_ADD_NOT_ZERO_OVF,
|
|
|
|
REFCOUNT_ADD_OVF,
|
|
|
|
REFCOUNT_ADD_UAF,
|
|
|
|
REFCOUNT_SUB_UAF,
|
|
|
|
REFCOUNT_DEC_LEAK,
|
|
|
|
};
|
|
|
|
|
|
|
|
void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_set - set a refcount's value
|
|
|
|
* @r: the refcount
|
|
|
|
* @n: value to which the refcount will be set
|
|
|
|
*/
|
|
|
|
static inline void refcount_set(refcount_t *r, int n)
|
|
|
|
{
|
|
|
|
atomic_set(&r->refs, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_read - get a refcount's value
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Return: the refcount's value
|
|
|
|
*/
|
|
|
|
static inline unsigned int refcount_read(const refcount_t *r)
|
|
|
|
{
|
|
|
|
return atomic_read(&r->refs);
|
|
|
|
}
|
|
|
|
|
2019-11-21 11:58:56 +00:00
|
|
|
/**
|
|
|
|
* refcount_add_not_zero - add a value to a refcount unless it is 0
|
|
|
|
* @i: the value to add to the refcount
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Will saturate at REFCOUNT_SATURATED and WARN.
|
|
|
|
*
|
|
|
|
* Provides no memory ordering, it is assumed the caller has guaranteed the
|
|
|
|
* object memory to be stable (RCU, etc.). It does provide a control dependency
|
|
|
|
* and thereby orders future stores. See the comment on top.
|
|
|
|
*
|
|
|
|
* Use of this function is not recommended for the normal reference counting
|
|
|
|
* use case in which references are taken and released one at a time. In these
|
|
|
|
* cases, refcount_inc(), or one of its variants, should instead be used to
|
|
|
|
* increment a reference count.
|
|
|
|
*
|
|
|
|
* Return: false if the passed refcount is 0, true otherwise
|
|
|
|
*/
|
|
|
|
static inline __must_check bool refcount_add_not_zero(int i, refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:57 +00:00
|
|
|
int old = refcount_read(r);
|
2019-11-21 11:58:56 +00:00
|
|
|
|
|
|
|
do {
|
2019-11-21 11:58:57 +00:00
|
|
|
if (!old)
|
|
|
|
break;
|
|
|
|
} while (!atomic_try_cmpxchg_relaxed(&r->refs, &old, old + i));
|
2019-11-21 11:58:56 +00:00
|
|
|
|
2019-11-21 11:58:58 +00:00
|
|
|
if (unlikely(old < 0 || old + i < 0))
|
|
|
|
refcount_warn_saturate(r, REFCOUNT_ADD_NOT_ZERO_OVF);
|
2019-11-21 11:58:56 +00:00
|
|
|
|
2019-11-21 11:58:57 +00:00
|
|
|
return old;
|
2019-11-21 11:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_add - add a value to a refcount
|
|
|
|
* @i: the value to add to the refcount
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Similar to atomic_add(), but will saturate at REFCOUNT_SATURATED and WARN.
|
|
|
|
*
|
|
|
|
* Provides no memory ordering, it is assumed the caller has guaranteed the
|
|
|
|
* object memory to be stable (RCU, etc.). It does provide a control dependency
|
|
|
|
* and thereby orders future stores. See the comment on top.
|
|
|
|
*
|
|
|
|
* Use of this function is not recommended for the normal reference counting
|
|
|
|
* use case in which references are taken and released one at a time. In these
|
|
|
|
* cases, refcount_inc(), or one of its variants, should instead be used to
|
|
|
|
* increment a reference count.
|
|
|
|
*/
|
|
|
|
static inline void refcount_add(int i, refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:57 +00:00
|
|
|
int old = atomic_fetch_add_relaxed(i, &r->refs);
|
|
|
|
|
2019-11-21 11:58:58 +00:00
|
|
|
if (unlikely(!old))
|
|
|
|
refcount_warn_saturate(r, REFCOUNT_ADD_UAF);
|
|
|
|
else if (unlikely(old < 0 || old + i < 0))
|
|
|
|
refcount_warn_saturate(r, REFCOUNT_ADD_OVF);
|
2019-11-21 11:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_inc_not_zero - increment a refcount unless it is 0
|
|
|
|
* @r: the refcount to increment
|
|
|
|
*
|
|
|
|
* Similar to atomic_inc_not_zero(), but will saturate at REFCOUNT_SATURATED
|
|
|
|
* and WARN.
|
|
|
|
*
|
|
|
|
* Provides no memory ordering, it is assumed the caller has guaranteed the
|
|
|
|
* object memory to be stable (RCU, etc.). It does provide a control dependency
|
|
|
|
* and thereby orders future stores. See the comment on top.
|
|
|
|
*
|
|
|
|
* Return: true if the increment was successful, false otherwise
|
|
|
|
*/
|
|
|
|
static inline __must_check bool refcount_inc_not_zero(refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:57 +00:00
|
|
|
return refcount_add_not_zero(1, r);
|
2019-11-21 11:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_inc - increment a refcount
|
|
|
|
* @r: the refcount to increment
|
|
|
|
*
|
|
|
|
* Similar to atomic_inc(), but will saturate at REFCOUNT_SATURATED and WARN.
|
|
|
|
*
|
|
|
|
* Provides no memory ordering, it is assumed the caller already has a
|
|
|
|
* reference on the object.
|
|
|
|
*
|
|
|
|
* Will WARN if the refcount is 0, as this represents a possible use-after-free
|
|
|
|
* condition.
|
|
|
|
*/
|
|
|
|
static inline void refcount_inc(refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:57 +00:00
|
|
|
refcount_add(1, r);
|
2019-11-21 11:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_sub_and_test - subtract from a refcount and test if it is 0
|
|
|
|
* @i: amount to subtract from the refcount
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Similar to atomic_dec_and_test(), but it will WARN, return false and
|
|
|
|
* ultimately leak on underflow and will fail to decrement when saturated
|
|
|
|
* at REFCOUNT_SATURATED.
|
|
|
|
*
|
|
|
|
* Provides release memory ordering, such that prior loads and stores are done
|
|
|
|
* before, and provides an acquire ordering on success such that free()
|
|
|
|
* must come after.
|
|
|
|
*
|
|
|
|
* Use of this function is not recommended for the normal reference counting
|
|
|
|
* use case in which references are taken and released one at a time. In these
|
|
|
|
* cases, refcount_dec(), or one of its variants, should instead be used to
|
|
|
|
* decrement a reference count.
|
|
|
|
*
|
|
|
|
* Return: true if the resulting refcount is 0, false otherwise
|
|
|
|
*/
|
|
|
|
static inline __must_check bool refcount_sub_and_test(int i, refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:57 +00:00
|
|
|
int old = atomic_fetch_sub_release(i, &r->refs);
|
2019-11-21 11:58:56 +00:00
|
|
|
|
2019-11-21 11:58:57 +00:00
|
|
|
if (old == i) {
|
2019-11-21 11:58:56 +00:00
|
|
|
smp_acquire__after_ctrl_dep();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-11-21 11:58:58 +00:00
|
|
|
if (unlikely(old < 0 || old - i < 0))
|
|
|
|
refcount_warn_saturate(r, REFCOUNT_SUB_UAF);
|
2019-11-21 11:58:57 +00:00
|
|
|
|
|
|
|
return false;
|
2019-11-21 11:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_dec_and_test - decrement a refcount and test if it is 0
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Similar to atomic_dec_and_test(), it will WARN on underflow and fail to
|
|
|
|
* decrement when saturated at REFCOUNT_SATURATED.
|
|
|
|
*
|
|
|
|
* Provides release memory ordering, such that prior loads and stores are done
|
|
|
|
* before, and provides an acquire ordering on success such that free()
|
|
|
|
* must come after.
|
|
|
|
*
|
|
|
|
* Return: true if the resulting refcount is 0, false otherwise
|
|
|
|
*/
|
|
|
|
static inline __must_check bool refcount_dec_and_test(refcount_t *r)
|
|
|
|
{
|
|
|
|
return refcount_sub_and_test(1, r);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* refcount_dec - decrement a refcount
|
|
|
|
* @r: the refcount
|
|
|
|
*
|
|
|
|
* Similar to atomic_dec(), it will WARN on underflow and fail to decrement
|
|
|
|
* when saturated at REFCOUNT_SATURATED.
|
|
|
|
*
|
|
|
|
* Provides release memory ordering, such that prior loads and stores are done
|
|
|
|
* before.
|
|
|
|
*/
|
|
|
|
static inline void refcount_dec(refcount_t *r)
|
|
|
|
{
|
2019-11-21 11:58:58 +00:00
|
|
|
if (unlikely(atomic_fetch_sub_release(1, &r->refs) <= 1))
|
|
|
|
refcount_warn_saturate(r, REFCOUNT_DEC_LEAK);
|
2019-11-21 11:58:57 +00:00
|
|
|
}
|
2016-11-14 17:06:19 +00:00
|
|
|
|
2017-02-10 15:27:52 +00:00
|
|
|
extern __must_check bool refcount_dec_if_one(refcount_t *r);
|
|
|
|
extern __must_check bool refcount_dec_not_one(refcount_t *r);
|
|
|
|
extern __must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock);
|
|
|
|
extern __must_check bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock);
|
2018-06-12 16:16:21 +00:00
|
|
|
extern __must_check bool refcount_dec_and_lock_irqsave(refcount_t *r,
|
|
|
|
spinlock_t *lock,
|
|
|
|
unsigned long *flags);
|
2016-11-14 17:06:19 +00:00
|
|
|
#endif /* _LINUX_REFCOUNT_H */
|