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 */
|
2006-06-26 07:25:05 +00:00
|
|
|
/* linux/include/linux/clocksource.h
|
|
|
|
|
*
|
|
|
|
|
* This file contains the structure definitions for clocksources.
|
|
|
|
|
*
|
|
|
|
|
* If you are not a clocksource, or timekeeping code, you should
|
|
|
|
|
* not be including this file!
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _LINUX_CLOCKSOURCE_H
|
|
|
|
|
#define _LINUX_CLOCKSOURCE_H
|
|
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/timex.h>
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
|
#include <linux/list.h>
|
2007-05-08 07:27:57 +00:00
|
|
|
#include <linux/cache.h>
|
2007-02-16 09:27:43 +00:00
|
|
|
#include <linux/timer.h>
|
2009-08-14 13:47:21 +00:00
|
|
|
#include <linux/init.h>
|
2016-03-10 00:16:54 +00:00
|
|
|
#include <linux/of.h>
|
2020-12-09 06:09:27 +00:00
|
|
|
#include <linux/clocksource_ids.h>
|
2006-06-26 07:25:05 +00:00
|
|
|
#include <asm/div64.h>
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
2007-02-16 09:27:43 +00:00
|
|
|
struct clocksource;
|
2013-04-25 20:31:44 +00:00
|
|
|
struct module;
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2020-02-07 12:38:55 +00:00
|
|
|
#if defined(CONFIG_ARCH_CLOCKSOURCE_DATA) || \
|
2020-02-07 12:38:59 +00:00
|
|
|
defined(CONFIG_GENERIC_GETTIMEOFDAY)
|
2011-07-13 13:24:13 +00:00
|
|
|
#include <asm/clocksource.h>
|
2011-07-21 20:34:05 +00:00
|
|
|
#endif
|
2011-07-13 13:24:13 +00:00
|
|
|
|
2020-03-20 14:53:33 +00:00
|
|
|
#include <vdso/clocksource.h>
|
2020-02-07 12:38:55 +00:00
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
/**
|
|
|
|
|
* struct clocksource - hardware abstraction for a free running counter
|
|
|
|
|
* Provides mostly state-free accessors to the underlying hardware.
|
2009-02-12 05:03:34 +00:00
|
|
|
* This is the structure used for system time.
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
2020-02-07 12:38:53 +00:00
|
|
|
* @read: Returns a cycle value, passes clocksource as argument
|
|
|
|
|
* @mask: Bitmask for two's complement
|
|
|
|
|
* subtraction of non 64 bit counters
|
|
|
|
|
* @mult: Cycle to nanosecond multiplier
|
|
|
|
|
* @shift: Cycle to nanosecond divisor (power of two)
|
|
|
|
|
* @max_idle_ns: Maximum idle time permitted by the clocksource (nsecs)
|
|
|
|
|
* @maxadj: Maximum adjustment value to mult (~11%)
|
clocksource: Reduce clocksource-skew threshold
Currently, WATCHDOG_THRESHOLD is set to detect a 62.5-millisecond skew in
a 500-millisecond WATCHDOG_INTERVAL. This requires that clocks be skewed
by more than 12.5% in order to be marked unstable. Except that a clock
that is skewed by that much is probably destroying unsuspecting software
right and left. And given that there are now checks for false-positive
skews due to delays between reading the two clocks, it should be possible
to greatly decrease WATCHDOG_THRESHOLD, at least for fine-grained clocks
such as TSC.
Therefore, add a new uncertainty_margin field to the clocksource structure
that contains the maximum uncertainty in nanoseconds for the corresponding
clock. This field may be initialized manually, as it is for
clocksource_tsc_early and clocksource_jiffies, which is copied to
refined_jiffies. If the field is not initialized manually, it will be
computed at clock-registry time as the period of the clock in question
based on the scale and freq parameters to __clocksource_update_freq_scale()
function. If either of those two parameters are zero, the
tens-of-milliseconds WATCHDOG_THRESHOLD is used as a cowardly alternative
to dividing by zero. No matter how the uncertainty_margin field is
calculated, it is bounded below by twice WATCHDOG_MAX_SKEW, that is, by 100
microseconds.
Note that manually initialized uncertainty_margin fields are not adjusted,
but there is a WARN_ON_ONCE() that triggers if any such field is less than
twice WATCHDOG_MAX_SKEW. This WARN_ON_ONCE() is intended to discourage
production use of the one-nanosecond uncertainty_margin values that are
used to test the clock-skew code itself.
The actual clock-skew check uses the sum of the uncertainty_margin fields
of the two clocksource structures being compared. Integer overflow is
avoided because the largest computed value of the uncertainty_margin
fields is one billion (10^9), and double that value fits into an
unsigned int. However, if someone manually specifies (say) UINT_MAX,
they will get what they deserve.
Note that the refined_jiffies uncertainty_margin field is initialized to
TICK_NSEC, which means that skew checks involving this clocksource will
be sufficently forgiving. In a similar vein, the clocksource_tsc_early
uncertainty_margin field is initialized to 32*NSEC_PER_MSEC, which
replicates the current behavior and allows custom setting if needed
in order to address the rare skews detected for this clocksource in
current mainline.
Suggested-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Feng Tang <feng.tang@intel.com>
Link: https://lore.kernel.org/r/20210527190124.440372-4-paulmck@kernel.org
2021-05-27 19:01:22 +00:00
|
|
|
* @uncertainty_margin: Maximum uncertainty in nanoseconds per half second.
|
|
|
|
|
* Zero says to use default WATCHDOG_THRESHOLD.
|
2020-02-07 12:38:53 +00:00
|
|
|
* @archdata: Optional arch-specific data
|
|
|
|
|
* @max_cycles: Maximum safe cycle value which won't overflow on
|
|
|
|
|
* multiplication
|
|
|
|
|
* @name: Pointer to clocksource name
|
|
|
|
|
* @list: List head for registration (internal)
|
|
|
|
|
* @rating: Rating value for selection (higher is better)
|
2006-06-26 07:25:05 +00:00
|
|
|
* To avoid rating inflation the following
|
|
|
|
|
* list should give you a guide as to how
|
|
|
|
|
* to assign your clocksource a rating
|
|
|
|
|
* 1-99: Unfit for real use
|
|
|
|
|
* Only available for bootup and testing purposes.
|
|
|
|
|
* 100-199: Base level usability.
|
|
|
|
|
* Functional for real use, but not desired.
|
|
|
|
|
* 200-299: Good.
|
|
|
|
|
* A correct and usable clocksource.
|
|
|
|
|
* 300-399: Desired.
|
|
|
|
|
* A reasonably fast and accurate clocksource.
|
|
|
|
|
* 400-499: Perfect
|
|
|
|
|
* The ideal clocksource. A must-use where
|
|
|
|
|
* available.
|
2020-12-09 06:09:27 +00:00
|
|
|
* @id: Defaults to CSID_GENERIC. The id value is captured
|
|
|
|
|
* in certain snapshot functions to allow callers to
|
|
|
|
|
* validate the clocksource from which the snapshot was
|
|
|
|
|
* taken.
|
2020-02-07 12:38:53 +00:00
|
|
|
* @flags: Flags describing special properties
|
|
|
|
|
* @enable: Optional function to enable the clocksource
|
|
|
|
|
* @disable: Optional function to disable the clocksource
|
|
|
|
|
* @suspend: Optional suspend function for the clocksource
|
|
|
|
|
* @resume: Optional resume function for the clocksource
|
2016-12-15 10:44:28 +00:00
|
|
|
* @mark_unstable: Optional function to inform the clocksource driver that
|
|
|
|
|
* the watchdog marked the clocksource unstable
|
2020-02-07 12:38:53 +00:00
|
|
|
* @tick_stable: Optional function called periodically from the watchdog
|
2021-03-22 21:39:03 +00:00
|
|
|
* code to provide stable synchronization points
|
2020-02-07 12:38:53 +00:00
|
|
|
* @wd_list: List head to enqueue into the watchdog list (internal)
|
|
|
|
|
* @cs_last: Last clocksource value for clocksource watchdog
|
|
|
|
|
* @wd_last: Last watchdog value corresponding to @cs_last
|
|
|
|
|
* @owner: Module reference, must be set by clocksource in modules
|
2015-11-19 10:43:09 +00:00
|
|
|
*
|
|
|
|
|
* Note: This struct is not used in hotpathes of the timekeeping code
|
|
|
|
|
* because the timekeeper caches the hot path fields in its own data
|
2020-02-07 12:38:53 +00:00
|
|
|
* structure, so no cache line alignment is required,
|
2015-11-19 10:43:09 +00:00
|
|
|
*
|
|
|
|
|
* The pointer to the clocksource itself is handed to the read
|
|
|
|
|
* callback. If you need extra information there you can wrap struct
|
|
|
|
|
* clocksource into your own struct. Depending on the amount of
|
|
|
|
|
* information you need you should consider to cache line align that
|
|
|
|
|
* structure.
|
2006-06-26 07:25:05 +00:00
|
|
|
*/
|
|
|
|
|
struct clocksource {
|
2020-02-07 12:38:53 +00:00
|
|
|
u64 (*read)(struct clocksource *cs);
|
|
|
|
|
u64 mask;
|
|
|
|
|
u32 mult;
|
|
|
|
|
u32 shift;
|
|
|
|
|
u64 max_idle_ns;
|
|
|
|
|
u32 maxadj;
|
clocksource: Reduce clocksource-skew threshold
Currently, WATCHDOG_THRESHOLD is set to detect a 62.5-millisecond skew in
a 500-millisecond WATCHDOG_INTERVAL. This requires that clocks be skewed
by more than 12.5% in order to be marked unstable. Except that a clock
that is skewed by that much is probably destroying unsuspecting software
right and left. And given that there are now checks for false-positive
skews due to delays between reading the two clocks, it should be possible
to greatly decrease WATCHDOG_THRESHOLD, at least for fine-grained clocks
such as TSC.
Therefore, add a new uncertainty_margin field to the clocksource structure
that contains the maximum uncertainty in nanoseconds for the corresponding
clock. This field may be initialized manually, as it is for
clocksource_tsc_early and clocksource_jiffies, which is copied to
refined_jiffies. If the field is not initialized manually, it will be
computed at clock-registry time as the period of the clock in question
based on the scale and freq parameters to __clocksource_update_freq_scale()
function. If either of those two parameters are zero, the
tens-of-milliseconds WATCHDOG_THRESHOLD is used as a cowardly alternative
to dividing by zero. No matter how the uncertainty_margin field is
calculated, it is bounded below by twice WATCHDOG_MAX_SKEW, that is, by 100
microseconds.
Note that manually initialized uncertainty_margin fields are not adjusted,
but there is a WARN_ON_ONCE() that triggers if any such field is less than
twice WATCHDOG_MAX_SKEW. This WARN_ON_ONCE() is intended to discourage
production use of the one-nanosecond uncertainty_margin values that are
used to test the clock-skew code itself.
The actual clock-skew check uses the sum of the uncertainty_margin fields
of the two clocksource structures being compared. Integer overflow is
avoided because the largest computed value of the uncertainty_margin
fields is one billion (10^9), and double that value fits into an
unsigned int. However, if someone manually specifies (say) UINT_MAX,
they will get what they deserve.
Note that the refined_jiffies uncertainty_margin field is initialized to
TICK_NSEC, which means that skew checks involving this clocksource will
be sufficently forgiving. In a similar vein, the clocksource_tsc_early
uncertainty_margin field is initialized to 32*NSEC_PER_MSEC, which
replicates the current behavior and allows custom setting if needed
in order to address the rare skews detected for this clocksource in
current mainline.
Suggested-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Feng Tang <feng.tang@intel.com>
Link: https://lore.kernel.org/r/20210527190124.440372-4-paulmck@kernel.org
2021-05-27 19:01:22 +00:00
|
|
|
u32 uncertainty_margin;
|
2011-07-21 20:34:05 +00:00
|
|
|
#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
|
2011-07-13 13:24:13 +00:00
|
|
|
struct arch_clocksource_data archdata;
|
2007-07-20 18:22:30 +00:00
|
|
|
#endif
|
2020-02-07 12:38:53 +00:00
|
|
|
u64 max_cycles;
|
|
|
|
|
const char *name;
|
|
|
|
|
struct list_head list;
|
|
|
|
|
int rating;
|
2020-12-09 06:09:27 +00:00
|
|
|
enum clocksource_ids id;
|
2020-02-07 12:38:55 +00:00
|
|
|
enum vdso_clock_mode vdso_clock_mode;
|
2020-02-07 12:38:53 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
int (*enable)(struct clocksource *cs);
|
|
|
|
|
void (*disable)(struct clocksource *cs);
|
|
|
|
|
void (*suspend)(struct clocksource *cs);
|
|
|
|
|
void (*resume)(struct clocksource *cs);
|
|
|
|
|
void (*mark_unstable)(struct clocksource *cs);
|
|
|
|
|
void (*tick_stable)(struct clocksource *cs);
|
2007-02-16 09:27:43 +00:00
|
|
|
|
2011-12-19 09:13:19 +00:00
|
|
|
/* private: */
|
2007-02-16 09:27:43 +00:00
|
|
|
#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
|
|
|
|
|
/* Watchdog related data, used by the framework */
|
2020-02-07 12:38:53 +00:00
|
|
|
struct list_head wd_list;
|
|
|
|
|
u64 cs_last;
|
|
|
|
|
u64 wd_last;
|
2007-02-16 09:27:43 +00:00
|
|
|
#endif
|
2020-02-07 12:38:53 +00:00
|
|
|
struct module *owner;
|
2015-11-19 10:43:09 +00:00
|
|
|
};
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2007-02-16 09:27:36 +00:00
|
|
|
/*
|
|
|
|
|
* Clock source flags bits::
|
|
|
|
|
*/
|
2007-02-16 09:27:43 +00:00
|
|
|
#define CLOCK_SOURCE_IS_CONTINUOUS 0x01
|
|
|
|
|
#define CLOCK_SOURCE_MUST_VERIFY 0x02
|
|
|
|
|
|
|
|
|
|
#define CLOCK_SOURCE_WATCHDOG 0x10
|
|
|
|
|
#define CLOCK_SOURCE_VALID_FOR_HRES 0x20
|
2009-08-14 13:47:25 +00:00
|
|
|
#define CLOCK_SOURCE_UNSTABLE 0x40
|
2013-03-12 03:56:46 +00:00
|
|
|
#define CLOCK_SOURCE_SUSPEND_NONSTOP 0x80
|
clocksource: Reselect clocksource when watchdog validated high-res capability
Up to commit 5d33b883a (clocksource: Always verify highres capability)
we had no sanity check when selecting a clocksource, which prevented
that a non highres capable clocksource is used when the system already
switched to highres/nohz mode.
The new sanity check works as Alex and Tim found out. It prevents the
TSC from being used. This happens because on x86 the boot process
looks like this:
tsc_start_freqency_validation(TSC);
clocksource_register(HPET);
clocksource_done_booting();
clocksource_select()
Selects HPET which is valid for high-res
switch_to_highres();
clocksource_register(TSC);
TSC is not selected, because it is not yet
flagged as VALID_HIGH_RES
clocksource_watchdog()
Validates TSC for highres, but that does not make TSC
the current clocksource.
Before the sanity check was added, we installed TSC unvalidated which
worked most of the time. If the TSC was really detected as unstable,
then the unstable logic removed it and installed HPET again.
The sanity check is correct and needed. So the watchdog needs to kick
a reselection of the clocksource, when it qualifies TSC as a valid
high res clocksource.
To solve this, we mark the clocksource which got the flag
CLOCK_SOURCE_VALID_FOR_HRES set by the watchdog with an new flag
CLOCK_SOURCE_RESELECT and trigger the watchdog thread. The watchdog
thread evaluates the flag and invokes clocksource_select() when set.
To avoid that the clocksource_done_booting() code, which is about to
install the first real clocksource anyway, needs to go through
clocksource_select and tick_oneshot_notify() pointlessly, split out
the clocksource_watchdog_kthread() list walk code and invoke the
select/notify only when called from clocksource_watchdog_kthread().
So clocksource_done_booting() can utilize the same splitout code
without the select/notify invocation and the clocksource_mutex
unlock/relock dance.
Reported-and-tested-by: Alex Shi <alex.shi@intel.com>
Cc: Hans Peter Anvin <hpa@linux.intel.com>
Cc: Tim Chen <tim.c.chen@linux.intel.com>
Cc: Andi Kleen <andi.kleen@intel.com>
Tested-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Davidlohr Bueso <davidlohr.bueso@hp.com>
Cc: John Stultz <john.stultz@linaro.org>
Link: http://lkml.kernel.org/r/alpine.DEB.2.02.1307042239150.11637@ionos.tec.linutronix.de
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2013-07-04 20:46:45 +00:00
|
|
|
#define CLOCK_SOURCE_RESELECT 0x100
|
2021-05-27 19:01:20 +00:00
|
|
|
#define CLOCK_SOURCE_VERIFY_PERCPU 0x200
|
2006-06-26 07:25:15 +00:00
|
|
|
/* simplify initialization of mask field */
|
2017-04-18 23:30:37 +00:00
|
|
|
#define CLOCKSOURCE_MASK(bits) GENMASK_ULL((bits) - 1, 0)
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2016-02-27 03:14:13 +00:00
|
|
|
static inline u32 clocksource_freq2mult(u32 freq, u32 shift_constant, u64 from)
|
|
|
|
|
{
|
|
|
|
|
/* freq = cyc/from
|
|
|
|
|
* mult/2^shift = ns/cyc
|
|
|
|
|
* mult = ns/cyc * 2^shift
|
|
|
|
|
* mult = from/freq * 2^shift
|
|
|
|
|
* mult = from * 2^shift / freq
|
|
|
|
|
* mult = (from<<shift) / freq
|
|
|
|
|
*/
|
|
|
|
|
u64 tmp = ((u64)from) << shift_constant;
|
|
|
|
|
|
|
|
|
|
tmp += freq/2; /* round for do_div */
|
|
|
|
|
do_div(tmp, freq);
|
|
|
|
|
|
|
|
|
|
return (u32)tmp;
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
/**
|
|
|
|
|
* clocksource_khz2mult - calculates mult from khz and shift
|
|
|
|
|
* @khz: Clocksource frequency in KHz
|
|
|
|
|
* @shift_constant: Clocksource shift factor
|
|
|
|
|
*
|
|
|
|
|
* Helper functions that converts a khz counter frequency to a timsource
|
|
|
|
|
* multiplier, given the clocksource shift value
|
|
|
|
|
*/
|
|
|
|
|
static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
|
|
|
|
|
{
|
2016-02-27 03:14:13 +00:00
|
|
|
return clocksource_freq2mult(khz, shift_constant, NSEC_PER_MSEC);
|
2006-06-26 07:25:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* clocksource_hz2mult - calculates mult from hz and shift
|
|
|
|
|
* @hz: Clocksource frequency in Hz
|
|
|
|
|
* @shift_constant: Clocksource shift factor
|
|
|
|
|
*
|
|
|
|
|
* Helper functions that converts a hz counter
|
|
|
|
|
* frequency to a timsource multiplier, given the
|
|
|
|
|
* clocksource shift value
|
|
|
|
|
*/
|
|
|
|
|
static inline u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
|
|
|
|
|
{
|
2016-02-27 03:14:13 +00:00
|
|
|
return clocksource_freq2mult(hz, shift_constant, NSEC_PER_SEC);
|
2006-06-26 07:25:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2009-08-14 13:47:26 +00:00
|
|
|
* clocksource_cyc2ns - converts clocksource cycles to nanoseconds
|
2011-12-19 09:13:19 +00:00
|
|
|
* @cycles: cycles
|
|
|
|
|
* @mult: cycle to nanosecond multiplier
|
|
|
|
|
* @shift: cycle to nanosecond divisor (power of two)
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
2016-11-28 22:35:20 +00:00
|
|
|
* Converts clocksource cycles to nanoseconds, using the given @mult and @shift.
|
|
|
|
|
* The code is optimized for performance and is not intended to work
|
|
|
|
|
* with absolute clocksource cycles (as those will easily overflow),
|
|
|
|
|
* but is only intended to be used with relative (delta) clocksource cycles.
|
2006-06-26 07:25:05 +00:00
|
|
|
*
|
|
|
|
|
* XXX - This could use some mult_lxl_ll() asm optimization
|
|
|
|
|
*/
|
2016-12-21 19:32:01 +00:00
|
|
|
static inline s64 clocksource_cyc2ns(u64 cycles, u32 mult, u32 shift)
|
2006-06-26 07:25:05 +00:00
|
|
|
{
|
2009-08-14 13:47:26 +00:00
|
|
|
return ((u64) cycles * mult) >> shift;
|
2006-06-26 07:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-04-25 20:31:46 +00:00
|
|
|
extern int clocksource_unregister(struct clocksource*);
|
2008-02-15 20:55:54 +00:00
|
|
|
extern void clocksource_touch_watchdog(void);
|
2007-02-16 09:27:33 +00:00
|
|
|
extern void clocksource_change_rating(struct clocksource *cs, int rating);
|
2010-02-02 22:41:41 +00:00
|
|
|
extern void clocksource_suspend(void);
|
2007-05-09 09:35:15 +00:00
|
|
|
extern void clocksource_resume(void);
|
2014-10-14 00:59:09 +00:00
|
|
|
extern struct clocksource * __init clocksource_default_clock(void);
|
2009-08-28 18:25:24 +00:00
|
|
|
extern void clocksource_mark_unstable(struct clocksource *cs);
|
2018-07-17 07:55:16 +00:00
|
|
|
extern void
|
|
|
|
|
clocksource_start_suspend_timing(struct clocksource *cs, u64 start_cycles);
|
|
|
|
|
extern u64 clocksource_stop_suspend_timing(struct clocksource *cs, u64 now);
|
2006-06-26 07:25:05 +00:00
|
|
|
|
2013-07-18 23:21:14 +00:00
|
|
|
extern u64
|
2015-03-12 04:16:31 +00:00
|
|
|
clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cycles);
|
2009-11-11 14:05:29 +00:00
|
|
|
extern void
|
|
|
|
|
clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);
|
|
|
|
|
|
2010-05-08 01:07:38 +00:00
|
|
|
/*
|
|
|
|
|
* Don't call __clocksource_register_scale directly, use
|
|
|
|
|
* clocksource_register_hz/khz
|
|
|
|
|
*/
|
|
|
|
|
extern int
|
|
|
|
|
__clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq);
|
2010-07-14 00:56:28 +00:00
|
|
|
extern void
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(struct clocksource *cs, u32 scale, u32 freq);
|
2010-05-08 01:07:38 +00:00
|
|
|
|
2015-03-12 04:16:37 +00:00
|
|
|
/*
|
|
|
|
|
* Don't call this unless you are a default clocksource
|
|
|
|
|
* (AKA: jiffies) and absolutely have to.
|
|
|
|
|
*/
|
|
|
|
|
static inline int __clocksource_register(struct clocksource *cs)
|
|
|
|
|
{
|
|
|
|
|
return __clocksource_register_scale(cs, 1, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-08 01:07:38 +00:00
|
|
|
static inline int clocksource_register_hz(struct clocksource *cs, u32 hz)
|
|
|
|
|
{
|
|
|
|
|
return __clocksource_register_scale(cs, 1, hz);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int clocksource_register_khz(struct clocksource *cs, u32 khz)
|
|
|
|
|
{
|
|
|
|
|
return __clocksource_register_scale(cs, 1000, khz);
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-12 04:16:40 +00:00
|
|
|
static inline void __clocksource_update_freq_hz(struct clocksource *cs, u32 hz)
|
2010-07-14 00:56:28 +00:00
|
|
|
{
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(cs, 1, hz);
|
2010-07-14 00:56:28 +00:00
|
|
|
}
|
|
|
|
|
|
2015-03-12 04:16:40 +00:00
|
|
|
static inline void __clocksource_update_freq_khz(struct clocksource *cs, u32 khz)
|
2010-07-14 00:56:28 +00:00
|
|
|
{
|
2015-03-12 04:16:40 +00:00
|
|
|
__clocksource_update_freq_scale(cs, 1000, khz);
|
2010-07-14 00:56:28 +00:00
|
|
|
}
|
2010-05-08 01:07:38 +00:00
|
|
|
|
2018-09-17 12:45:34 +00:00
|
|
|
#ifdef CONFIG_ARCH_CLOCKSOURCE_INIT
|
|
|
|
|
extern void clocksource_arch_init(struct clocksource *cs);
|
|
|
|
|
#else
|
|
|
|
|
static inline void clocksource_arch_init(struct clocksource *cs) { }
|
|
|
|
|
#endif
|
2007-02-16 09:28:17 +00:00
|
|
|
|
2013-04-25 20:31:44 +00:00
|
|
|
extern int timekeeping_notify(struct clocksource *clock);
|
2009-08-14 13:47:30 +00:00
|
|
|
|
2016-12-21 19:32:01 +00:00
|
|
|
extern u64 clocksource_mmio_readl_up(struct clocksource *);
|
|
|
|
|
extern u64 clocksource_mmio_readl_down(struct clocksource *);
|
|
|
|
|
extern u64 clocksource_mmio_readw_up(struct clocksource *);
|
|
|
|
|
extern u64 clocksource_mmio_readw_down(struct clocksource *);
|
2011-05-08 13:06:52 +00:00
|
|
|
|
|
|
|
|
extern int clocksource_mmio_init(void __iomem *, const char *,
|
2016-12-21 19:32:01 +00:00
|
|
|
unsigned long, int, unsigned, u64 (*)(struct clocksource *));
|
2011-05-08 13:06:52 +00:00
|
|
|
|
2011-05-08 17:50:20 +00:00
|
|
|
extern int clocksource_i8253_init(void);
|
|
|
|
|
|
2017-05-26 14:56:11 +00:00
|
|
|
#define TIMER_OF_DECLARE(name, compat, fn) \
|
2017-05-26 16:33:27 +00:00
|
|
|
OF_DECLARE_1_RET(timer, name, compat, fn)
|
2016-05-31 14:25:59 +00:00
|
|
|
|
2017-05-26 17:34:11 +00:00
|
|
|
#ifdef CONFIG_TIMER_PROBE
|
2017-05-26 15:40:46 +00:00
|
|
|
extern void timer_probe(void);
|
2013-01-30 17:49:30 +00:00
|
|
|
#else
|
2017-05-26 15:40:46 +00:00
|
|
|
static inline void timer_probe(void) {}
|
2012-11-19 23:41:20 +00:00
|
|
|
#endif
|
|
|
|
|
|
2017-05-26 15:42:25 +00:00
|
|
|
#define TIMER_ACPI_DECLARE(name, table_id, fn) \
|
2017-05-26 16:33:27 +00:00
|
|
|
ACPI_DECLARE_PROBE_ENTRY(timer, name, table_id, 0, NULL, 0, fn)
|
2015-09-28 14:49:15 +00:00
|
|
|
|
clocksource: Scale the watchdog read retries automatically
On a 8-socket server the TSC is wrongly marked as 'unstable' and disabled
during boot time on about one out of 120 boot attempts:
clocksource: timekeeping watchdog on CPU227: wd-tsc-wd excessive read-back delay of 153560ns vs. limit of 125000ns,
wd-wd read-back delay only 11440ns, attempt 3, marking tsc unstable
tsc: Marking TSC unstable due to clocksource watchdog
TSC found unstable after boot, most likely due to broken BIOS. Use 'tsc=unstable'.
sched_clock: Marking unstable (119294969739, 159204297)<-(125446229205, -5992055152)
clocksource: Checking clocksource tsc synchronization from CPU 319 to CPUs 0,99,136,180,210,542,601,896.
clocksource: Switched to clocksource hpet
The reason is that for platform with a large number of CPUs, there are
sporadic big or huge read latencies while reading the watchog/clocksource
during boot or when system is under stress work load, and the frequency and
maximum value of the latency goes up with the number of online CPUs.
The cCurrent code already has logic to detect and filter such high latency
case by reading the watchdog twice and checking the two deltas. Due to the
randomness of the latency, there is a low probabilty that the first delta
(latency) is big, but the second delta is small and looks valid. The
watchdog code retries the readouts by default twice, which is not
necessarily sufficient for systems with a large number of CPUs.
There is a command line parameter 'max_cswd_read_retries' which allows to
increase the number of retries, but that's not user friendly as it needs to
be tweaked per system. As the number of required retries is proportional to
the number of online CPUs, this parameter can be calculated at runtime.
Scale and enlarge the number of retries according to the number of online
CPUs and remove the command line parameter completely.
[ tglx: Massaged change log and comments ]
Signed-off-by: Feng Tang <feng.tang@intel.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Jin Wang <jin1.wang@intel.com>
Tested-by: Paul E. McKenney <paulmck@kernel.org>
Reviewed-by: Waiman Long <longman@redhat.com>
Reviewed-by: Paul E. McKenney <paulmck@kernel.org>
Link: https://lore.kernel.org/r/20240221060859.1027450-1-feng.tang@intel.com
2024-02-21 06:08:59 +00:00
|
|
|
static inline unsigned int clocksource_get_max_watchdog_retry(void)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* When system is in the boot phase or under heavy workload, there
|
|
|
|
|
* can be random big latencies during the clocksource/watchdog
|
|
|
|
|
* read, so allow retries to filter the noise latency. As the
|
|
|
|
|
* latency's frequency and maximum value goes up with the number of
|
|
|
|
|
* CPUs, scale the number of retries with the number of online
|
|
|
|
|
* CPUs.
|
|
|
|
|
*/
|
|
|
|
|
return (ilog2(num_online_cpus()) / 2) + 1;
|
|
|
|
|
}
|
|
|
|
|
|
clocksource: Provide kernel module to test clocksource watchdog
When the clocksource watchdog marks a clock as unstable, this might
be due to that clock being unstable or it might be due to delays that
happen to occur between the reads of the two clocks. It would be good
to have a way of testing the clocksource watchdog's ability to
distinguish between these two causes of clock skew and instability.
Therefore, provide a new clocksource-wdtest module selected by a new
TEST_CLOCKSOURCE_WATCHDOG Kconfig option. This module has a single module
parameter named "holdoff" that provides the number of seconds of delay
before testing should start, which defaults to zero when built as a module
and to 10 seconds when built directly into the kernel. Very large systems
that boot slowly may need to increase the value of this module parameter.
This module uses hand-crafted clocksource structures to do its testing,
thus avoiding messing up timing for the rest of the kernel and for user
applications. This module first verifies that the ->uncertainty_margin
field of the clocksource structures are set sanely. It then tests the
delay-detection capability of the clocksource watchdog, increasing the
number of consecutive delays injected, first provoking console messages
complaining about the delays and finally forcing a clock-skew event.
Unexpected test results cause at least one WARN_ON_ONCE() console splat.
If there are no splats, the test has passed. Finally, it fuzzes the
value returned from a clocksource to test the clocksource watchdog's
ability to detect time skew.
This module checks the state of its clocksource after each test, and
uses WARN_ON_ONCE() to emit a console splat if there are any failures.
This should enable all types of test frameworks to detect any such
failures.
This facility is intended for diagnostic use only, and should be avoided
on production systems.
Reported-by: Chris Mason <clm@fb.com>
Suggested-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Feng Tang <feng.tang@intel.com>
Link: https://lore.kernel.org/r/20210527190124.440372-5-paulmck@kernel.org
2021-05-27 19:01:23 +00:00
|
|
|
void clocksource_verify_percpu(struct clocksource *cs);
|
|
|
|
|
|
2006-06-26 07:25:05 +00:00
|
|
|
#endif /* _LINUX_CLOCKSOURCE_H */
|