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 17:07:57 +03:00
// SPDX-License-Identifier: GPL-2.0
2010-05-08 01:11:44 +04:00
/*
* Detect hard and soft lockups on a system
*
* started by Don Zickus , Copyright ( C ) 2010 Red Hat , Inc .
*
2012-02-10 02:42:22 +04:00
* Note : Most of this code is borrowed heavily from the original softlockup
* detector , so thanks to Ingo for the initial implementation .
* Some chunks also taken from the old x86 - specific nmi watchdog code , thanks
2010-05-08 01:11:44 +04:00
* to those contributors as well .
*/
2017-07-15 00:49:46 +03:00
# define pr_fmt(fmt) "watchdog: " fmt
2012-03-24 02:01:55 +04:00
2010-05-08 01:11:44 +04:00
# include <linux/mm.h>
# include <linux/cpu.h>
# include <linux/nmi.h>
# include <linux/init.h>
# include <linux/module.h>
# include <linux/sysctl.h>
2015-06-25 02:55:45 +03:00
# include <linux/tick.h>
2017-02-01 18:36:40 +03:00
# include <linux/sched/clock.h>
2017-02-08 20:51:35 +03:00
# include <linux/sched/debug.h>
2017-10-27 05:42:28 +03:00
# include <linux/sched/isolation.h>
2018-06-07 11:52:03 +03:00
# include <linux/stop_machine.h>
2010-05-08 01:11:44 +04:00
# include <asm/irq_regs.h>
2012-03-10 23:37:28 +04:00
# include <linux/kvm_para.h>
2010-05-08 01:11:44 +04:00
2017-09-12 22:37:01 +03:00
static DEFINE_MUTEX ( watchdog_mutex ) ;
2015-05-18 12:31:50 +03:00
2017-07-13 00:35:46 +03:00
# if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HAVE_NMI_WATCHDOG)
2017-09-12 22:37:17 +03:00
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED | NMI_WATCHDOG_ENABLED)
# define NMI_WATCHDOG_DEFAULT 1
2015-04-15 01:43:55 +03:00
# else
2017-09-12 22:37:17 +03:00
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED)
# define NMI_WATCHDOG_DEFAULT 0
2015-04-15 01:43:55 +03:00
# endif
2017-07-13 00:35:46 +03:00
2017-09-12 22:37:17 +03:00
unsigned long __read_mostly watchdog_enabled ;
int __read_mostly watchdog_user_enabled = 1 ;
int __read_mostly nmi_watchdog_user_enabled = NMI_WATCHDOG_DEFAULT ;
int __read_mostly soft_watchdog_user_enabled = 1 ;
2017-09-12 22:37:15 +03:00
int __read_mostly watchdog_thresh = 10 ;
2019-03-12 12:33:48 +03:00
static int __read_mostly nmi_watchdog_available ;
2017-09-12 22:37:15 +03:00
2019-03-12 12:33:48 +03:00
static struct cpumask watchdog_allowed_mask __read_mostly ;
2017-09-12 22:37:15 +03:00
struct cpumask watchdog_cpumask __read_mostly ;
unsigned long * watchdog_cpumask_bits = cpumask_bits ( & watchdog_cpumask ) ;
2017-07-13 00:35:46 +03:00
# ifdef CONFIG_HARDLOCKUP_DETECTOR
/*
* Should we panic when a soft - lockup or hard - lockup occurs :
*/
unsigned int __read_mostly hardlockup_panic =
CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE ;
/*
* We may not want to enable hard lockup detection by default in all cases ,
* for example when running the kernel as a guest on a hypervisor . In these
* cases this function can be called to disable hard lockup detection . This
* function should only be executed once by the boot processor before the
* kernel command line parameters are parsed , because otherwise it is not
* possible to override this in hardlockup_panic_setup ( ) .
*/
2017-09-12 22:37:02 +03:00
void __init hardlockup_detector_disable ( void )
2017-07-13 00:35:46 +03:00
{
2017-09-12 22:37:17 +03:00
nmi_watchdog_user_enabled = 0 ;
2017-07-13 00:35:46 +03:00
}
static int __init hardlockup_panic_setup ( char * str )
{
if ( ! strncmp ( str , " panic " , 5 ) )
hardlockup_panic = 1 ;
else if ( ! strncmp ( str , " nopanic " , 7 ) )
hardlockup_panic = 0 ;
else if ( ! strncmp ( str , " 0 " , 1 ) )
2017-09-12 22:37:17 +03:00
nmi_watchdog_user_enabled = 0 ;
2017-07-13 00:35:46 +03:00
else if ( ! strncmp ( str , " 1 " , 1 ) )
2017-09-12 22:37:17 +03:00
nmi_watchdog_user_enabled = 1 ;
2017-07-13 00:35:46 +03:00
return 1 ;
}
__setup ( " nmi_watchdog= " , hardlockup_panic_setup ) ;
2017-09-12 22:37:07 +03:00
# ifdef CONFIG_SMP
int __read_mostly sysctl_hardlockup_all_cpu_backtrace ;
2017-07-13 00:35:46 +03:00
2017-09-12 22:37:07 +03:00
static int __init hardlockup_all_cpu_backtrace_setup ( char * str )
{
sysctl_hardlockup_all_cpu_backtrace = ! ! simple_strtol ( str , NULL , 0 ) ;
return 1 ;
}
__setup ( " hardlockup_all_cpu_backtrace= " , hardlockup_all_cpu_backtrace_setup ) ;
# endif /* CONFIG_SMP */
# endif /* CONFIG_HARDLOCKUP_DETECTOR */
2017-07-13 00:35:46 +03:00
/*
* These functions can be overridden if an architecture implements its
* own hardlockup detector .
2017-07-13 00:35:49 +03:00
*
* watchdog_nmi_enable / disable can be implemented to start and stop when
* softlockup watchdog threads start and stop . The arch must select the
* SOFTLOCKUP_DETECTOR Kconfig .
2017-07-13 00:35:46 +03:00
*/
int __weak watchdog_nmi_enable ( unsigned int cpu )
{
2017-09-12 22:37:21 +03:00
hardlockup_detector_perf_enable ( ) ;
2017-07-13 00:35:46 +03:00
return 0 ;
}
2017-09-12 22:37:04 +03:00
2017-07-13 00:35:46 +03:00
void __weak watchdog_nmi_disable ( unsigned int cpu )
{
2017-09-12 22:37:04 +03:00
hardlockup_detector_perf_disable ( ) ;
2017-07-13 00:35:46 +03:00
}
2017-09-12 22:37:19 +03:00
/* Return 0, if a NMI watchdog is available. Error code otherwise */
int __weak __init watchdog_nmi_probe ( void )
{
return hardlockup_detector_perf_init ( ) ;
}
2017-09-12 22:37:16 +03:00
/**
2017-10-02 13:34:50 +03:00
* watchdog_nmi_stop - Stop the watchdog for reconfiguration
2017-09-12 22:37:16 +03:00
*
2017-10-02 13:34:50 +03:00
* The reconfiguration steps are :
* watchdog_nmi_stop ( ) ;
2017-09-12 22:37:16 +03:00
* update_variables ( ) ;
2017-10-02 13:34:50 +03:00
* watchdog_nmi_start ( ) ;
*/
void __weak watchdog_nmi_stop ( void ) { }
/**
* watchdog_nmi_start - Start the watchdog after reconfiguration
2017-09-12 22:37:16 +03:00
*
2017-10-02 13:34:50 +03:00
* Counterpart to watchdog_nmi_stop ( ) .
*
* The following variables have been updated in update_variables ( ) and
* contain the currently valid configuration :
2017-09-12 22:37:15 +03:00
* - watchdog_enabled
2017-07-13 00:35:49 +03:00
* - watchdog_thresh
* - watchdog_cpumask
*/
2017-10-02 13:34:50 +03:00
void __weak watchdog_nmi_start ( void ) { }
2017-07-13 00:35:49 +03:00
2017-09-12 22:37:17 +03:00
/**
* lockup_detector_update_enable - Update the sysctl enable bit
*
* Caller needs to make sure that the NMI / perf watchdogs are off , so this
* can ' t race with watchdog_nmi_disable ( ) .
*/
static void lockup_detector_update_enable ( void )
{
watchdog_enabled = 0 ;
if ( ! watchdog_user_enabled )
return ;
2017-09-12 22:37:19 +03:00
if ( nmi_watchdog_available & & nmi_watchdog_user_enabled )
2017-09-12 22:37:17 +03:00
watchdog_enabled | = NMI_WATCHDOG_ENABLED ;
if ( soft_watchdog_user_enabled )
watchdog_enabled | = SOFT_WATCHDOG_ENABLED ;
}
2017-07-13 00:35:46 +03:00
# ifdef CONFIG_SOFTLOCKUP_DETECTOR
2020-01-16 21:17:02 +03:00
# define SOFTLOCKUP_RESET ULONG_MAX
2017-09-12 22:37:06 +03:00
/* Global variables, exported for sysctl */
unsigned int __read_mostly softlockup_panic =
CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE ;
2017-09-12 22:37:10 +03:00
2018-06-07 11:52:03 +03:00
static bool softlockup_initialized __read_mostly ;
2012-12-18 03:59:50 +04:00
static u64 __read_mostly sample_period ;
2010-05-08 01:11:44 +04:00
static DEFINE_PER_CPU ( unsigned long , watchdog_touch_ts ) ;
static DEFINE_PER_CPU ( struct hrtimer , watchdog_hrtimer ) ;
static DEFINE_PER_CPU ( bool , softlockup_touch_sync ) ;
static DEFINE_PER_CPU ( bool , soft_watchdog_warn ) ;
2012-07-16 14:42:38 +04:00
static DEFINE_PER_CPU ( unsigned long , hrtimer_interrupts ) ;
2010-05-08 01:11:44 +04:00
static DEFINE_PER_CPU ( unsigned long , hrtimer_interrupts_saved ) ;
2014-06-24 00:22:05 +04:00
static unsigned long soft_lockup_nmi_warn ;
2010-05-08 01:11:44 +04:00
static int __init softlockup_panic_setup ( char * str )
{
softlockup_panic = simple_strtoul ( str , NULL , 0 ) ;
return 1 ;
}
__setup ( " softlockup_panic= " , softlockup_panic_setup ) ;
static int __init nowatchdog_setup ( char * str )
{
2017-09-12 22:37:17 +03:00
watchdog_user_enabled = 0 ;
2010-05-08 01:11:44 +04:00
return 1 ;
}
__setup ( " nowatchdog " , nowatchdog_setup ) ;
static int __init nosoftlockup_setup ( char * str )
{
2017-09-12 22:37:17 +03:00
soft_watchdog_user_enabled = 0 ;
2010-05-08 01:11:44 +04:00
return 1 ;
}
__setup ( " nosoftlockup " , nosoftlockup_setup ) ;
2015-04-15 01:44:13 +03:00
2018-11-01 16:30:18 +03:00
static int __init watchdog_thresh_setup ( char * str )
{
get_option ( & str , & watchdog_thresh ) ;
return 1 ;
}
__setup ( " watchdog_thresh= " , watchdog_thresh_setup ) ;
2014-06-24 00:22:05 +04:00
# ifdef CONFIG_SMP
2017-09-12 22:37:07 +03:00
int __read_mostly sysctl_softlockup_all_cpu_backtrace ;
2014-06-24 00:22:05 +04:00
static int __init softlockup_all_cpu_backtrace_setup ( char * str )
{
2017-09-12 22:37:07 +03:00
sysctl_softlockup_all_cpu_backtrace = ! ! simple_strtol ( str , NULL , 0 ) ;
2014-06-24 00:22:05 +04:00
return 1 ;
}
__setup ( " softlockup_all_cpu_backtrace= " , softlockup_all_cpu_backtrace_setup ) ;
2017-07-13 00:35:46 +03:00
# endif
2010-05-08 01:11:44 +04:00
2017-09-12 22:37:04 +03:00
static void __lockup_detector_cleanup ( void ) ;
2011-05-23 09:10:23 +04:00
/*
* Hard - lockup warnings should be triggered after just a few seconds . Soft -
* lockups can have false positives under extreme conditions . So we generally
* want a higher threshold for soft lockups than for hard lockups . So we couple
* the thresholds with a factor : we make the soft threshold twice the amount of
* time the hard threshold is .
*/
2011-05-24 07:43:18 +04:00
static int get_softlockup_thresh ( void )
2011-05-23 09:10:23 +04:00
{
return watchdog_thresh * 2 ;
}
2010-05-08 01:11:44 +04:00
/*
* Returns seconds , approximately . We don ' t need nanosecond
* resolution , and we don ' t need to waste time with a big divide when
* 2 ^ 30 ns = = 1.074 s .
*/
2012-12-27 06:49:44 +04:00
static unsigned long get_timestamp ( void )
2010-05-08 01:11:44 +04:00
{
2015-02-13 02:01:24 +03:00
return running_clock ( ) > > 30LL ; /* 2^30 ~= 10^9 */
2010-05-08 01:11:44 +04:00
}
2012-12-18 03:59:50 +04:00
static void set_sample_period ( void )
2010-05-08 01:11:44 +04:00
{
/*
2011-05-23 09:10:22 +04:00
* convert watchdog_thresh from seconds to ns
2012-02-10 02:42:22 +04:00
* the divide by 5 is to give hrtimer several chances ( two
* or three with the current relation between the soft
* and hard thresholds ) to increment before the
* hardlockup detector generates a warning
2010-05-08 01:11:44 +04:00
*/
2012-12-18 03:59:50 +04:00
sample_period = get_softlockup_thresh ( ) * ( ( u64 ) NSEC_PER_SEC / 5 ) ;
2017-08-15 10:50:13 +03:00
watchdog_update_hrtimer_threshold ( sample_period ) ;
2010-05-08 01:11:44 +04:00
}
/* Commands for resetting the watchdog */
static void __touch_watchdog ( void )
{
2012-12-27 06:49:44 +04:00
__this_cpu_write ( watchdog_touch_ts , get_timestamp ( ) ) ;
2010-05-08 01:11:44 +04:00
}
2015-12-08 19:28:04 +03:00
/**
* touch_softlockup_watchdog_sched - touch watchdog on scheduler stalls
*
* Call when the scheduler may have stalled for legitimate reasons
* preventing the watchdog task from executing - e . g . the scheduler
* entering idle state . This should only be used for scheduler events .
* Use touch_softlockup_watchdog ( ) for everything else .
*/
2018-08-21 18:25:07 +03:00
notrace void touch_softlockup_watchdog_sched ( void )
2010-05-08 01:11:44 +04:00
{
2014-04-19 02:07:12 +04:00
/*
* Preemption can be enabled . It doesn ' t matter which CPU ' s timestamp
* gets zeroed here , so use the raw_ operation .
*/
2020-01-16 21:17:02 +03:00
raw_cpu_write ( watchdog_touch_ts , SOFTLOCKUP_RESET ) ;
2010-05-08 01:11:44 +04:00
}
2015-12-08 19:28:04 +03:00
2018-08-21 18:25:07 +03:00
notrace void touch_softlockup_watchdog ( void )
2015-12-08 19:28:04 +03:00
{
touch_softlockup_watchdog_sched ( ) ;
workqueue: implement lockup detector
Workqueue stalls can happen from a variety of usage bugs such as
missing WQ_MEM_RECLAIM flag or concurrency managed work item
indefinitely staying RUNNING. These stalls can be extremely difficult
to hunt down because the usual warning mechanisms can't detect
workqueue stalls and the internal state is pretty opaque.
To alleviate the situation, this patch implements workqueue lockup
detector. It periodically monitors all worker_pools periodically and,
if any pool failed to make forward progress longer than the threshold
duration, triggers warning and dumps workqueue state as follows.
BUG: workqueue lockup - pool cpus=0 node=0 flags=0x0 nice=0 stuck for 31s!
Showing busy workqueues and worker pools:
workqueue events: flags=0x0
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=17/256
pending: monkey_wrench_fn, e1000_watchdog, cache_reap, vmstat_shepherd, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, cgroup_release_agent
workqueue events_power_efficient: flags=0x80
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=2/256
pending: check_lifetime, neigh_periodic_work
workqueue cgroup_pidlist_destroy: flags=0x0
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=1/1
pending: cgroup_pidlist_destroy_work_fn
...
The detection mechanism is controller through kernel parameter
workqueue.watchdog_thresh and can be updated at runtime through the
sysfs module parameter file.
v2: Decoupled from softlockup control knobs.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Don Zickus <dzickus@redhat.com>
Cc: Ulrich Obergfell <uobergfe@redhat.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Chris Mason <clm@fb.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
2015-12-08 19:28:04 +03:00
wq_watchdog_touch ( raw_smp_processor_id ( ) ) ;
2015-12-08 19:28:04 +03:00
}
2010-05-13 10:53:33 +04:00
EXPORT_SYMBOL ( touch_softlockup_watchdog ) ;
2010-05-08 01:11:44 +04:00
2010-05-08 01:11:45 +04:00
void touch_all_softlockup_watchdogs ( void )
2010-05-08 01:11:44 +04:00
{
int cpu ;
/*
2017-09-12 22:37:11 +03:00
* watchdog_mutex cannpt be taken here , as this might be called
* from ( soft ) interrupt context , so the access to
* watchdog_allowed_cpumask might race with a concurrent update .
*
* The watchdog time stamp can race against a concurrent real
* update as well , the only side effect might be a cycle delay for
* the softlockup check .
2010-05-08 01:11:44 +04:00
*/
2017-09-12 22:37:11 +03:00
for_each_cpu ( cpu , & watchdog_allowed_mask )
2020-01-16 21:17:02 +03:00
per_cpu ( watchdog_touch_ts , cpu ) = SOFTLOCKUP_RESET ;
workqueue: implement lockup detector
Workqueue stalls can happen from a variety of usage bugs such as
missing WQ_MEM_RECLAIM flag or concurrency managed work item
indefinitely staying RUNNING. These stalls can be extremely difficult
to hunt down because the usual warning mechanisms can't detect
workqueue stalls and the internal state is pretty opaque.
To alleviate the situation, this patch implements workqueue lockup
detector. It periodically monitors all worker_pools periodically and,
if any pool failed to make forward progress longer than the threshold
duration, triggers warning and dumps workqueue state as follows.
BUG: workqueue lockup - pool cpus=0 node=0 flags=0x0 nice=0 stuck for 31s!
Showing busy workqueues and worker pools:
workqueue events: flags=0x0
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=17/256
pending: monkey_wrench_fn, e1000_watchdog, cache_reap, vmstat_shepherd, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, release_one_tty, cgroup_release_agent
workqueue events_power_efficient: flags=0x80
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=2/256
pending: check_lifetime, neigh_periodic_work
workqueue cgroup_pidlist_destroy: flags=0x0
pwq 0: cpus=0 node=0 flags=0x0 nice=0 active=1/1
pending: cgroup_pidlist_destroy_work_fn
...
The detection mechanism is controller through kernel parameter
workqueue.watchdog_thresh and can be updated at runtime through the
sysfs module parameter file.
v2: Decoupled from softlockup control knobs.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Don Zickus <dzickus@redhat.com>
Cc: Ulrich Obergfell <uobergfe@redhat.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Chris Mason <clm@fb.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
2015-12-08 19:28:04 +03:00
wq_watchdog_touch ( - 1 ) ;
2010-05-08 01:11:44 +04:00
}
void touch_softlockup_watchdog_sync ( void )
{
2014-08-17 21:30:34 +04:00
__this_cpu_write ( softlockup_touch_sync , true ) ;
2020-01-16 21:17:02 +03:00
__this_cpu_write ( watchdog_touch_ts , SOFTLOCKUP_RESET ) ;
2010-05-08 01:11:44 +04:00
}
2010-05-18 02:06:04 +04:00
static int is_softlockup ( unsigned long touch_ts )
2010-05-08 01:11:44 +04:00
{
2012-12-27 06:49:44 +04:00
unsigned long now = get_timestamp ( ) ;
2010-05-08 01:11:44 +04:00
2015-11-06 05:44:56 +03:00
if ( ( watchdog_enabled & SOFT_WATCHDOG_ENABLED ) & & watchdog_thresh ) {
2015-04-15 01:44:13 +03:00
/* Warn about unreasonable delays. */
if ( time_after ( now , touch_ts + get_softlockup_thresh ( ) ) )
return now - touch_ts ;
}
2010-05-08 01:11:44 +04:00
return 0 ;
}
2017-07-13 00:35:46 +03:00
/* watchdog detector functions */
bool is_hardlockup ( void )
2010-05-08 01:11:44 +04:00
{
2017-07-13 00:35:46 +03:00
unsigned long hrint = __this_cpu_read ( hrtimer_interrupts ) ;
2012-07-16 14:42:38 +04:00
2017-07-13 00:35:46 +03:00
if ( __this_cpu_read ( hrtimer_interrupts_saved ) = = hrint )
return true ;
__this_cpu_write ( hrtimer_interrupts_saved , hrint ) ;
return false ;
2016-12-15 02:06:24 +03:00
}
2017-07-13 00:35:46 +03:00
static void watchdog_interrupt_count ( void )
2016-12-15 02:06:24 +03:00
{
2017-07-13 00:35:46 +03:00
__this_cpu_inc ( hrtimer_interrupts ) ;
2016-12-15 02:06:24 +03:00
}
2010-05-08 01:11:44 +04:00
2018-07-13 13:42:08 +03:00
static DEFINE_PER_CPU ( struct completion , softlockup_completion ) ;
static DEFINE_PER_CPU ( struct cpu_stop_work , softlockup_stop_work ) ;
2018-06-07 11:52:03 +03:00
/*
* The watchdog thread function - touches the timestamp .
*
* It only runs once every sample_period seconds ( 4 seconds by
* default ) to reset the softlockup timestamp . If this gets delayed
* for more than 2 * watchdog_thresh seconds then the debug - printout
* triggers in watchdog_timer_fn ( ) .
*/
static int softlockup_fn ( void * data )
{
__touch_watchdog ( ) ;
2018-07-13 13:42:08 +03:00
complete ( this_cpu_ptr ( & softlockup_completion ) ) ;
2018-06-07 11:52:03 +03:00
return 0 ;
}
2010-05-08 01:11:44 +04:00
/* watchdog kicker functions */
static enum hrtimer_restart watchdog_timer_fn ( struct hrtimer * hrtimer )
{
2010-12-08 18:22:55 +03:00
unsigned long touch_ts = __this_cpu_read ( watchdog_touch_ts ) ;
2010-05-08 01:11:44 +04:00
struct pt_regs * regs = get_irq_regs ( ) ;
int duration ;
2014-06-24 00:22:05 +04:00
int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace ;
2010-05-08 01:11:44 +04:00
2017-09-12 22:37:05 +03:00
if ( ! watchdog_enabled )
2017-01-25 02:17:53 +03:00
return HRTIMER_NORESTART ;
2010-05-08 01:11:44 +04:00
/* kick the hardlockup detector */
watchdog_interrupt_count ( ) ;
/* kick the softlockup detector */
2018-07-13 13:42:08 +03:00
if ( completion_done ( this_cpu_ptr ( & softlockup_completion ) ) ) {
reinit_completion ( this_cpu_ptr ( & softlockup_completion ) ) ;
stop_one_cpu_nowait ( smp_processor_id ( ) ,
softlockup_fn , NULL ,
this_cpu_ptr ( & softlockup_stop_work ) ) ;
}
2010-05-08 01:11:44 +04:00
/* .. and repeat */
2012-12-18 03:59:50 +04:00
hrtimer_forward_now ( hrtimer , ns_to_ktime ( sample_period ) ) ;
2010-05-08 01:11:44 +04:00
2020-01-16 21:17:02 +03:00
if ( touch_ts = = SOFTLOCKUP_RESET ) {
2010-12-08 18:22:55 +03:00
if ( unlikely ( __this_cpu_read ( softlockup_touch_sync ) ) ) {
2010-05-08 01:11:44 +04:00
/*
* If the time stamp was touched atomically
* make sure the scheduler tick is up to date .
*/
2010-12-08 18:22:55 +03:00
__this_cpu_write ( softlockup_touch_sync , false ) ;
2010-05-08 01:11:44 +04:00
sched_clock_tick ( ) ;
}
2012-03-10 23:37:28 +04:00
/* Clear the guest paused flag on watchdog reset */
kvm_check_and_clear_guest_paused ( ) ;
2010-05-08 01:11:44 +04:00
__touch_watchdog ( ) ;
return HRTIMER_RESTART ;
}
/* check for a softlockup
* This is done by making sure a high priority task is
* being scheduled . The task touches the watchdog to
* indicate it is getting cpu time . If it hasn ' t then
* this is a good indication some task is hogging the cpu
*/
2010-05-18 02:06:04 +04:00
duration = is_softlockup ( touch_ts ) ;
2010-05-08 01:11:44 +04:00
if ( unlikely ( duration ) ) {
2012-03-10 23:37:28 +04:00
/*
* If a virtual machine is stopped by the host it can look to
* the watchdog like a soft lockup , check to see if the host
* stopped the vm before we issue the warning
*/
if ( kvm_check_and_clear_guest_paused ( ) )
return HRTIMER_RESTART ;
2010-05-08 01:11:44 +04:00
/* only warn once */
2019-10-24 14:49:26 +03:00
if ( __this_cpu_read ( soft_watchdog_warn ) = = true )
2010-05-08 01:11:44 +04:00
return HRTIMER_RESTART ;
2014-06-24 00:22:05 +04:00
if ( softlockup_all_cpu_backtrace ) {
/* Prevent multiple soft-lockup reports if one cpu is already
* engaged in dumping cpu back traces
*/
if ( test_and_set_bit ( 0 , & soft_lockup_nmi_warn ) ) {
/* Someone else will report us. Let's give up */
__this_cpu_write ( soft_watchdog_warn , true ) ;
return HRTIMER_RESTART ;
}
}
2014-08-07 03:04:03 +04:00
pr_emerg ( " BUG: soft lockup - CPU#%d stuck for %us! [%s:%d] \n " ,
2010-05-18 02:06:04 +04:00
smp_processor_id ( ) , duration ,
2010-05-08 01:11:44 +04:00
current - > comm , task_pid_nr ( current ) ) ;
print_modules ( ) ;
print_irqtrace_events ( current ) ;
if ( regs )
show_regs ( regs ) ;
else
dump_stack ( ) ;
2014-06-24 00:22:05 +04:00
if ( softlockup_all_cpu_backtrace ) {
/* Avoid generating two back traces for current
* given that one is already made above
*/
trigger_allbutself_cpu_backtrace ( ) ;
clear_bit ( 0 , & soft_lockup_nmi_warn ) ;
/* Barrier to sync with other cpus */
smp_mb__after_atomic ( ) ;
}
2014-08-09 01:22:31 +04:00
add_taint ( TAINT_SOFTLOCKUP , LOCKDEP_STILL_OK ) ;
2010-05-08 01:11:44 +04:00
if ( softlockup_panic )
panic ( " softlockup: hung tasks " ) ;
2010-12-08 18:22:55 +03:00
__this_cpu_write ( soft_watchdog_warn , true ) ;
2010-05-08 01:11:44 +04:00
} else
2010-12-08 18:22:55 +03:00
__this_cpu_write ( soft_watchdog_warn , false ) ;
2010-05-08 01:11:44 +04:00
return HRTIMER_RESTART ;
}
2012-07-16 14:42:38 +04:00
static void watchdog_enable ( unsigned int cpu )
2010-05-08 01:11:44 +04:00
{
2017-09-12 22:37:05 +03:00
struct hrtimer * hrtimer = this_cpu_ptr ( & watchdog_hrtimer ) ;
2018-07-13 13:42:08 +03:00
struct completion * done = this_cpu_ptr ( & softlockup_completion ) ;
2010-05-08 01:11:44 +04:00
2018-06-07 11:52:03 +03:00
WARN_ON_ONCE ( cpu ! = smp_processor_id ( ) ) ;
2018-07-13 13:42:08 +03:00
init_completion ( done ) ;
complete ( done ) ;
2017-09-12 22:37:05 +03:00
/*
* Start the timer first to prevent the NMI watchdog triggering
* before the timer has a chance to fire .
*/
2019-07-26 21:30:54 +03:00
hrtimer_init ( hrtimer , CLOCK_MONOTONIC , HRTIMER_MODE_REL_HARD ) ;
2012-12-19 23:51:31 +04:00
hrtimer - > function = watchdog_timer_fn ;
2017-09-12 22:37:05 +03:00
hrtimer_start ( hrtimer , ns_to_ktime ( sample_period ) ,
2019-07-26 21:30:54 +03:00
HRTIMER_MODE_REL_PINNED_HARD ) ;
2012-12-19 23:51:31 +04:00
2017-09-12 22:37:05 +03:00
/* Initialize timestamp */
__touch_watchdog ( ) ;
2012-07-16 14:42:38 +04:00
/* Enable the perf event */
2017-09-12 22:37:21 +03:00
if ( watchdog_enabled & NMI_WATCHDOG_ENABLED )
watchdog_nmi_enable ( cpu ) ;
2012-07-16 14:42:38 +04:00
}
2010-05-08 01:11:44 +04:00
2012-07-16 14:42:38 +04:00
static void watchdog_disable ( unsigned int cpu )
{
2017-09-12 22:37:05 +03:00
struct hrtimer * hrtimer = this_cpu_ptr ( & watchdog_hrtimer ) ;
2010-05-08 01:11:44 +04:00
2018-06-07 11:52:03 +03:00
WARN_ON_ONCE ( cpu ! = smp_processor_id ( ) ) ;
2017-09-12 22:37:05 +03:00
/*
* Disable the perf event first . That prevents that a large delay
* between disabling the timer and disabling the perf event causes
* the perf NMI to detect a false positive .
*/
2012-07-16 14:42:38 +04:00
watchdog_nmi_disable ( cpu ) ;
2017-09-12 22:37:05 +03:00
hrtimer_cancel ( hrtimer ) ;
2018-07-13 13:42:08 +03:00
wait_for_completion ( this_cpu_ptr ( & softlockup_completion ) ) ;
2010-05-08 01:11:44 +04:00
}
2018-06-07 11:52:03 +03:00
static int softlockup_stop_fn ( void * data )
2013-06-06 17:42:53 +04:00
{
2018-06-07 11:52:03 +03:00
watchdog_disable ( smp_processor_id ( ) ) ;
return 0 ;
2013-06-06 17:42:53 +04:00
}
2018-06-07 11:52:03 +03:00
static void softlockup_stop_all ( void )
2012-07-16 14:42:38 +04:00
{
2018-06-07 11:52:03 +03:00
int cpu ;
if ( ! softlockup_initialized )
return ;
for_each_cpu ( cpu , & watchdog_allowed_mask )
smp_call_on_cpu ( cpu , softlockup_stop_fn , NULL , false ) ;
cpumask_clear ( & watchdog_allowed_mask ) ;
2012-07-16 14:42:38 +04:00
}
2018-06-07 11:52:03 +03:00
static int softlockup_start_fn ( void * data )
2012-07-16 14:42:38 +04:00
{
2018-06-07 11:52:03 +03:00
watchdog_enable ( smp_processor_id ( ) ) ;
return 0 ;
2012-07-16 14:42:38 +04:00
}
2010-05-08 01:11:44 +04:00
2018-06-07 11:52:03 +03:00
static void softlockup_start_all ( void )
2017-09-12 22:37:10 +03:00
{
2018-06-07 11:52:03 +03:00
int cpu ;
2017-09-12 22:37:10 +03:00
2018-06-07 11:52:03 +03:00
cpumask_copy ( & watchdog_allowed_mask , & watchdog_cpumask ) ;
for_each_cpu ( cpu , & watchdog_allowed_mask )
smp_call_on_cpu ( cpu , softlockup_start_fn , NULL , false ) ;
2017-09-12 22:37:10 +03:00
}
2018-06-07 11:52:03 +03:00
int lockup_detector_online_cpu ( unsigned int cpu )
2017-09-12 22:37:10 +03:00
{
2019-03-27 00:51:02 +03:00
if ( cpumask_test_cpu ( cpu , & watchdog_allowed_mask ) )
watchdog_enable ( cpu ) ;
2018-06-07 11:52:03 +03:00
return 0 ;
2017-09-12 22:37:10 +03:00
}
2018-06-07 11:52:03 +03:00
int lockup_detector_offline_cpu ( unsigned int cpu )
2017-09-12 22:37:10 +03:00
{
2019-03-27 00:51:02 +03:00
if ( cpumask_test_cpu ( cpu , & watchdog_allowed_mask ) )
watchdog_disable ( cpu ) ;
2018-06-07 11:52:03 +03:00
return 0 ;
2017-09-12 22:37:10 +03:00
}
2017-10-04 11:03:04 +03:00
static void lockup_detector_reconfigure ( void )
2017-09-12 22:37:10 +03:00
{
2017-10-03 17:37:53 +03:00
cpus_read_lock ( ) ;
2017-10-02 13:34:50 +03:00
watchdog_nmi_stop ( ) ;
2018-06-07 11:52:03 +03:00
softlockup_stop_all ( ) ;
2017-09-12 22:37:10 +03:00
set_sample_period ( ) ;
2017-09-12 22:37:17 +03:00
lockup_detector_update_enable ( ) ;
if ( watchdog_enabled & & watchdog_thresh )
2018-06-07 11:52:03 +03:00
softlockup_start_all ( ) ;
2017-10-02 13:34:50 +03:00
watchdog_nmi_start ( ) ;
2017-10-03 17:37:53 +03:00
cpus_read_unlock ( ) ;
/*
* Must be called outside the cpus locked section to prevent
* recursive locking in the perf code .
*/
__lockup_detector_cleanup ( ) ;
2017-09-12 22:37:10 +03:00
}
/*
2017-10-04 11:03:04 +03:00
* Create the watchdog thread infrastructure and configure the detector ( s ) .
2017-09-12 22:37:10 +03:00
*
* The threads are not unparked as watchdog_allowed_mask is empty . When
2019-03-23 05:28:32 +03:00
* the threads are successfully initialized , take the proper locks and
2017-09-12 22:37:10 +03:00
* unpark the threads in the watchdog_cpumask if the watchdog is enabled .
*/
2017-10-04 11:03:04 +03:00
static __init void lockup_detector_setup ( void )
2017-09-12 22:37:10 +03:00
{
/*
* If sysctl is off and watchdog got disabled on the command line ,
* nothing to do here .
*/
2017-09-12 22:37:17 +03:00
lockup_detector_update_enable ( ) ;
2017-09-12 22:37:10 +03:00
if ( ! IS_ENABLED ( CONFIG_SYSCTL ) & &
! ( watchdog_enabled & & watchdog_thresh ) )
return ;
mutex_lock ( & watchdog_mutex ) ;
2017-10-04 11:03:04 +03:00
lockup_detector_reconfigure ( ) ;
2018-06-07 11:52:03 +03:00
softlockup_initialized = true ;
2017-09-12 22:37:10 +03:00
mutex_unlock ( & watchdog_mutex ) ;
}
2017-09-12 22:37:06 +03:00
# else /* CONFIG_SOFTLOCKUP_DETECTOR */
2017-10-04 11:03:04 +03:00
static void lockup_detector_reconfigure ( void )
2017-09-12 22:37:16 +03:00
{
2017-10-03 17:37:53 +03:00
cpus_read_lock ( ) ;
2017-10-02 13:34:50 +03:00
watchdog_nmi_stop ( ) ;
2017-09-12 22:37:17 +03:00
lockup_detector_update_enable ( ) ;
2017-10-02 13:34:50 +03:00
watchdog_nmi_start ( ) ;
2017-10-03 17:37:53 +03:00
cpus_read_unlock ( ) ;
2017-09-12 22:37:16 +03:00
}
2017-10-04 11:03:04 +03:00
static inline void lockup_detector_setup ( void )
2017-10-03 17:39:02 +03:00
{
2017-10-04 11:03:04 +03:00
lockup_detector_reconfigure ( ) ;
2017-10-03 17:39:02 +03:00
}
2017-09-12 22:37:06 +03:00
# endif /* !CONFIG_SOFTLOCKUP_DETECTOR */
2017-07-13 00:35:46 +03:00
2017-09-12 22:37:04 +03:00
static void __lockup_detector_cleanup ( void )
{
lockdep_assert_held ( & watchdog_mutex ) ;
hardlockup_detector_perf_cleanup ( ) ;
}
/**
* lockup_detector_cleanup - Cleanup after cpu hotplug or sysctl changes
*
* Caller must not hold the cpu hotplug rwsem .
*/
void lockup_detector_cleanup ( void )
{
mutex_lock ( & watchdog_mutex ) ;
__lockup_detector_cleanup ( ) ;
mutex_unlock ( & watchdog_mutex ) ;
}
2017-09-12 22:36:57 +03:00
/**
* lockup_detector_soft_poweroff - Interface to stop lockup detector ( s )
*
* Special interface for parisc . It prevents lockup detector warnings from
* the default pm_poweroff ( ) function which busy loops forever .
*/
void lockup_detector_soft_poweroff ( void )
{
watchdog_enabled = 0 ;
}
2015-11-06 05:44:30 +03:00
# ifdef CONFIG_SYSCTL
2017-09-12 22:37:12 +03:00
/* Propagate any changes to the watchdog threads */
2017-09-12 22:37:11 +03:00
static void proc_watchdog_update ( void )
2015-04-15 01:43:58 +03:00
{
2017-09-12 22:37:12 +03:00
/* Remove impossible cpus to keep sysctl output clean. */
cpumask_and ( & watchdog_cpumask , & watchdog_cpumask , cpu_possible_mask ) ;
2017-10-04 11:03:04 +03:00
lockup_detector_reconfigure ( ) ;
2015-04-15 01:43:58 +03:00
}
2015-04-15 01:44:05 +03:00
/*
* common function for watchdog , nmi_watchdog and soft_watchdog parameter
*
2017-09-12 22:37:15 +03:00
* caller | table - > data points to | ' which '
* - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - -
* proc_watchdog | watchdog_user_enabled | NMI_WATCHDOG_ENABLED |
* | | SOFT_WATCHDOG_ENABLED
* - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - -
* proc_nmi_watchdog | nmi_watchdog_user_enabled | NMI_WATCHDOG_ENABLED
* - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - - - - | - - - - - - - - - - - - - - - - - - - - - - - - - -
* proc_soft_watchdog | soft_watchdog_user_enabled | SOFT_WATCHDOG_ENABLED
2015-04-15 01:44:05 +03:00
*/
static int proc_watchdog_common ( int which , struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
{
2017-09-12 22:37:17 +03:00
int err , old , * param = table - > data ;
2015-04-15 01:44:05 +03:00
2017-09-12 22:37:01 +03:00
mutex_lock ( & watchdog_mutex ) ;
2015-04-15 01:44:05 +03:00
if ( ! write ) {
2017-09-12 22:37:17 +03:00
/*
* On read synchronize the userspace interface . This is a
* racy snapshot .
*/
* param = ( watchdog_enabled & which ) ! = 0 ;
2015-04-15 01:44:05 +03:00
err = proc_dointvec_minmax ( table , write , buffer , lenp , ppos ) ;
} else {
2017-09-12 22:37:17 +03:00
old = READ_ONCE ( * param ) ;
2015-04-15 01:44:05 +03:00
err = proc_dointvec_minmax ( table , write , buffer , lenp , ppos ) ;
2017-09-12 22:37:17 +03:00
if ( ! err & & old ! = READ_ONCE ( * param ) )
2017-09-12 22:37:11 +03:00
proc_watchdog_update ( ) ;
2015-04-15 01:44:05 +03:00
}
2017-09-12 22:37:01 +03:00
mutex_unlock ( & watchdog_mutex ) ;
2015-04-15 01:44:05 +03:00
return err ;
}
2015-04-15 01:44:08 +03:00
/*
* / proc / sys / kernel / watchdog
*/
int proc_watchdog ( struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
{
return proc_watchdog_common ( NMI_WATCHDOG_ENABLED | SOFT_WATCHDOG_ENABLED ,
table , write , buffer , lenp , ppos ) ;
}
/*
* / proc / sys / kernel / nmi_watchdog
2010-05-08 01:11:44 +04:00
*/
2015-04-15 01:44:08 +03:00
int proc_nmi_watchdog ( struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
{
2017-09-12 22:37:19 +03:00
if ( ! nmi_watchdog_available & & write )
return - ENOTSUPP ;
2015-04-15 01:44:08 +03:00
return proc_watchdog_common ( NMI_WATCHDOG_ENABLED ,
table , write , buffer , lenp , ppos ) ;
}
/*
* / proc / sys / kernel / soft_watchdog
*/
int proc_soft_watchdog ( struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
{
return proc_watchdog_common ( SOFT_WATCHDOG_ENABLED ,
table , write , buffer , lenp , ppos ) ;
}
2010-05-08 01:11:44 +04:00
2015-04-15 01:44:08 +03:00
/*
* / proc / sys / kernel / watchdog_thresh
*/
int proc_watchdog_thresh ( struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
2010-05-08 01:11:44 +04:00
{
2017-09-12 22:37:11 +03:00
int err , old ;
2010-05-08 01:11:44 +04:00
2017-09-12 22:37:01 +03:00
mutex_lock ( & watchdog_mutex ) ;
2012-07-16 14:42:38 +04:00
2017-09-12 22:37:11 +03:00
old = READ_ONCE ( watchdog_thresh ) ;
2013-06-06 17:42:53 +04:00
err = proc_dointvec_minmax ( table , write , buffer , lenp , ppos ) ;
2015-04-15 01:44:08 +03:00
2017-09-12 22:37:11 +03:00
if ( ! err & & write & & old ! = READ_ONCE ( watchdog_thresh ) )
proc_watchdog_update ( ) ;
2011-05-23 09:10:21 +04:00
2017-09-12 22:37:01 +03:00
mutex_unlock ( & watchdog_mutex ) ;
2013-06-06 17:42:53 +04:00
return err ;
2010-05-08 01:11:44 +04:00
}
2015-06-25 02:55:45 +03:00
/*
* The cpumask is the mask of possible cpus that the watchdog can run
* on , not the mask of cpus it is actually running on . This allows the
* user to specify a mask that will include cpus that have not yet
* been brought online , if desired .
*/
int proc_watchdog_cpumask ( struct ctl_table * table , int write ,
void __user * buffer , size_t * lenp , loff_t * ppos )
{
int err ;
2017-09-12 22:37:01 +03:00
mutex_lock ( & watchdog_mutex ) ;
2015-09-05 01:45:18 +03:00
2015-06-25 02:55:45 +03:00
err = proc_do_large_bitmap ( table , write , buffer , lenp , ppos ) ;
2017-09-12 22:37:08 +03:00
if ( ! err & & write )
2017-09-12 22:37:12 +03:00
proc_watchdog_update ( ) ;
2017-09-12 22:36:59 +03:00
2017-09-12 22:37:01 +03:00
mutex_unlock ( & watchdog_mutex ) ;
2015-06-25 02:55:45 +03:00
return err ;
}
2010-05-08 01:11:44 +04:00
# endif /* CONFIG_SYSCTL */
2010-11-25 20:38:29 +03:00
void __init lockup_detector_init ( void )
2010-05-08 01:11:44 +04:00
{
2017-10-27 05:42:29 +03:00
if ( tick_nohz_full_enabled ( ) )
2015-09-05 01:45:09 +03:00
pr_info ( " Disabling watchdog on nohz_full cores by default \n " ) ;
2017-10-27 05:42:29 +03:00
2017-10-27 05:42:35 +03:00
cpumask_copy ( & watchdog_cpumask ,
housekeeping_cpumask ( HK_FLAG_TIMER ) ) ;
2015-06-25 02:55:45 +03:00
2017-09-12 22:37:19 +03:00
if ( ! watchdog_nmi_probe ( ) )
nmi_watchdog_available = true ;
2017-10-04 11:03:04 +03:00
lockup_detector_setup ( ) ;
2010-05-08 01:11:44 +04:00
}