8b338e2310
* aosp/android-4.19-stable: Revert "xhci: Add grace period after xHC start to prevent premature runtime suspend." Revert "USB: core: Prevent nested device-reset calls" Revert "mm/rmap: Fix anon_vma->degree ambiguity leading to double-reuse" Revert "sched/deadline: Fix priority inheritance with multiple scheduling classes" Revert "kernel/sched: Remove dl_boosted flag comment" Revert "fs: check FMODE_LSEEK to control internal pipe splicing" Linux 4.19.259 tracefs: Only clobber mode/uid/gid on remount if asked net: dp83822: disable rx error interrupt mm: Fix TLB flush for not-first PFNMAP mappings in unmap_region() usb: storage: Add ASUS <0x0b05:0x1932> to IGNORE_UAS platform/x86: acer-wmi: Acer Aspire One AOD270/Packard Bell Dot keymap fixes perf/arm_pmu_platform: fix tests for platform_get_irq() failure Input: iforce - add support for Boeder Force Feedback Wheel ieee802154: cc2520: add rc code in cc2520_tx() tg3: Disable tg3 device on system reboot to avoid triggering AER HID: ishtp-hid-clientHID: ishtp-hid-client: Fix comment typo drm/msm/rd: Fix FIFO-full deadlock Linux 4.19.258 SUNRPC: use _bh spinlocking on ->transport_lock MIPS: loongson32: ls1c: Fix hang during startup x86/nospec: Fix i386 RSB stuffing usb: dwc3: qcom: fix use-after-free on runtime-PM wakeup USB: serial: ch341: fix disabled rx timer on older devices USB: serial: ch341: fix lost character on LCR updates usb: dwc3: fix PHY disable sequence sch_sfb: Also store skb len before calling child enqueue tcp: fix early ETIMEDOUT after spurious non-SACK RTO RDMA/mlx5: Set local port to one when accessing counters ipv6: sr: fix out-of-bounds read when setting HMAC data. i40e: Fix kernel crash during module removal tipc: fix shift wrapping bug in map_get() sch_sfb: Don't assume the skb is still around after enqueueing to child netfilter: nf_conntrack_irc: Fix forged IP logic netfilter: br_netfilter: Drop dst references before setting. soc: brcmstb: pm-arm: Fix refcount leak and __iomem leak bugs scsi: mpt3sas: Fix use-after-free warning debugfs: add debugfs_lookup_and_remove() kprobes: Prohibit probes in gate area ALSA: usb-audio: Fix an out-of-bounds bug in __snd_usb_parse_audio_interface() ALSA: aloop: Fix random zeros in capture data when using jiffies timer ALSA: emu10k1: Fix out of bounds access in snd_emu10k1_pcm_channel_alloc() drm/amdgpu: mmVM_L2_CNTL3 register not initialized correctly fbdev: chipsfb: Add missing pci_disable_device() in chipsfb_pci_init() arm64: cacheinfo: Fix incorrect assignment of signed error value to unsigned fw_level parisc: Add runtime check to prevent PA2.0 kernels on PA1.x machines parisc: ccio-dma: Handle kmalloc failure in ccio_init_resources() drm/radeon: add a force flush to delay work when radeon drm/amdgpu: Check num_gfx_rings for gfx v9_0 rb setup. ALSA: seq: Fix data-race at module auto-loading ALSA: seq: oss: Fix data-race for max_midi_devs access net: mac802154: Fix a condition in the receive path wifi: mac80211: Don't finalize CSA in IBSS mode if state is disconnected usb: gadget: mass_storage: Fix cdrom data transfers on MAC-OS USB: core: Prevent nested device-reset calls s390: fix nospec table alignments s390/hugetlb: fix prepare_hugepage_range() check for 2 GB hugepages usb-storage: Add ignore-residue quirk for NXP PN7462AU USB: cdc-acm: Add Icom PMR F3400 support (0c26:0020) usb: dwc2: fix wrong order of phy_power_on and phy_init usb: typec: altmodes/displayport: correct pin assignment for UFP receptacles USB: serial: option: add support for Cinterion MV32-WA/WB RmNet mode USB: serial: option: add Quectel EM060K modem USB: serial: option: add support for OPPO R11 diag port USB: serial: cp210x: add Decagon UCA device id xhci: Add grace period after xHC start to prevent premature runtime suspend. thunderbolt: Use the actual buffer in tb_async_error() hwmon: (gpio-fan) Fix array out of bounds access Input: rk805-pwrkey - fix module autoloading clk: core: Fix runtime PM sequence in clk_core_unprepare() Revert "clk: core: Honor CLK_OPS_PARENT_ENABLE for clk gate ops" clk: core: Honor CLK_OPS_PARENT_ENABLE for clk gate ops drm/i915/reg: Fix spelling mistake "Unsupport" -> "Unsupported" binder: fix UAF of ref->proc caused by race condition USB: serial: ftdi_sio: add Omron CS1W-CIF31 device id vt: Clear selection before changing the font staging: rtl8712: fix use after free bugs serial: fsl_lpuart: RS485 RTS polariy is inverse net/smc: Remove redundant refcount increase Revert "sch_cake: Return __NET_XMIT_STOLEN when consuming enqueued skb" tcp: annotate data-race around challenge_timestamp sch_cake: Return __NET_XMIT_STOLEN when consuming enqueued skb kcm: fix strp_init() order and cleanup ethernet: rocker: fix sleep in atomic context bug in neigh_timer_handler Revert "xhci: turn off port power in shutdown" wifi: cfg80211: debugfs: fix return type in ht40allow_map_read() ieee802154/adf7242: defer destroy_workqueue call platform/x86: pmc_atom: Fix SLP_TYPx bitfield mask drm/msm/dsi: Fix number of regulators for msm8996_dsi_cfg drm/msm/dsi: fix the inconsistent indenting net: dp83822: disable false carrier interrupt Revert "mm: kmemleak: take a full lowmem check in kmemleak_*_phys()" fs: only do a memory barrier for the first set_buffer_uptodate() wifi: iwlegacy: 4965: corrected fix for potential off-by-one overflow in il4965_rs_fill_link_cmd() efi: capsule-loader: Fix use-after-free in efi_capsule_write driver core: Don't probe devices after bus_type.match() probe deferral Linux 4.19.257 net: neigh: don't call kfree_skb() under spin_lock_irqsave() kprobes: don't call disarm_kprobe() for disabled kprobes netfilter: conntrack: NF_CONNTRACK_PROCFS should no longer default to y s390/hypfs: avoid error message under KVM neigh: fix possible DoS due to net iface start/stop loop drm/amd/display: clear optc underflow before turn off odm clock mm/rmap: Fix anon_vma->degree ambiguity leading to double-reuse ftrace: Fix NULL pointer dereference in is_ftrace_trampoline when ftrace is dead fbdev: fb_pm2fb: Avoid potential divide by zero error HID: hidraw: fix memory leak in hidraw_release() media: pvrusb2: fix memory leak in pvr_probe HID: steam: Prevent NULL pointer dereference in steam_{recv,send}_report Bluetooth: L2CAP: Fix build errors in some archs kbuild: Fix include path in scripts/Makefile.modpost x86/bugs: Add "unknown" reporting for MMIO Stale Data s390/mm: do not trigger write fault when vma does not allow VM_WRITE selftests/bpf: Fix test_align verifier log patterns bpf: Fix the off-by-two error in range markings arm64: map FDT as RW for early_init_dt_scan() mm: Force TLB flush for PFNMAP mappings before unlink_file_vma() scsi: storvsc: Remove WQ_MEM_RECLAIM from storvsc_error_wq md: call __md_stop_writes in md_stop mm/hugetlb: fix hugetlb not supporting softdirty tracking s390: fix double free of GS and RI CBs on fork() failure asm-generic: sections: refactor memory_intersects loop: Check for overflow while configuring loop x86/unwind/orc: Unwind ftrace trampolines with correct ORC entry btrfs: check if root is readonly while setting security xattr ixgbe: stop resetting SYSTIME in ixgbe_ptp_start_cyclecounter net: Fix a data-race around sysctl_somaxconn. net: Fix a data-race around netdev_budget_usecs. net: Fix a data-race around netdev_budget. net: Fix a data-race around sysctl_net_busy_read. net: Fix a data-race around sysctl_net_busy_poll. net: Fix a data-race around sysctl_tstamp_allow_data. ratelimit: Fix data-races in ___ratelimit(). net: Fix data-races around netdev_tstamp_prequeue. net: Fix data-races around weight_p and dev_weight_[rt]x_bias. netfilter: nft_tunnel: restrict it to netdev family netfilter: nft_osf: restrict osf to ipv4, ipv6 and inet families netfilter: nft_payload: do not truncate csum_offset and csum_type netfilter: nft_payload: report ERANGE for too long offset and length netfilter: ebtables: reject blobs that don't provide all entry points net: ipvtap - add __init/__exit annotations to module init/exit funcs bonding: 802.3ad: fix no transmission of LACPDUs rose: check NULL rose_loopback_neigh->loopback af_key: Do not call xfrm_probe_algs in parallel xfrm: fix refcount leak in __xfrm_policy_check() kernel/sched: Remove dl_boosted flag comment sched/deadline: Fix priority inheritance with multiple scheduling classes sched/deadline: Fix stale throttling on de-/boosted tasks sched/deadline: Unthrottle PI boosted threads while enqueuing pinctrl: amd: Don't save/restore interrupt status and wake status bits kernel/sys_ni: add compat entry for fadvise64_64 parisc: Fix exception handler for fldw and fstw instructions audit: fix potential double free on error path from fsnotify_add_inode_mark Linux 4.19.256 btrfs: raid56: don't trust any cached sector in __raid56_parity_recover() btrfs: only write the sectors in the vertical stripe which has data stripes tracing/probes: Have kprobes and uprobes use $COMM too tee: add overflow check in register_shm_helper() MIPS: tlbex: Explicitly compare _PAGE_NO_EXEC against 0 video: fbdev: i740fb: Check the argument of i740_calc_vclk() powerpc/64: Init jump labels before parse_early_param() smb3: check xattr value length earlier f2fs: fix to avoid use f2fs_bug_on() in f2fs_new_node_page() ALSA: timer: Use deferred fasync helper ALSA: core: Add async signal helpers watchdog: export lockup_detector_reconfigure RISC-V: Add fast call path of crash_kexec() riscv: mmap with PROT_WRITE but no PROT_READ is invalid mips: cavium-octeon: Fix missing of_node_put() in octeon2_usb_clocks_start vfio: Clear the caps->buf to NULL after free tty: serial: Fix refcount leak bug in ucc_uart.c lib/list_debug.c: Detect uninitialized lists ext4: avoid resizing to a partial cluster size ext4: avoid remove directory when directory is corrupted drivers:md:fix a potential use-after-free bug dmaengine: sprd: Cleanup in .remove() after pm_runtime_get_sync() failed cxl: Fix a memory leak in an error handling path gadgetfs: ep_io - wait until IRQ finishes clk: qcom: ipq8074: dont disable gcc_sleep_clk_src vboxguest: Do not use devm for irq usb: renesas: Fix refcount leak bug usb: host: ohci-ppc-of: Fix refcount leak bug irqchip/tegra: Fix overflow implicit truncation warnings PCI: Add ACS quirk for Broadcom BCM5750x NICs drm/meson: Fix refcount bugs in meson_vpu_has_available_connectors() locking/atomic: Make test_and_*_bit() ordered on failure gcc-plugins: Undefine LATENT_ENTROPY_PLUGIN when plugin disabled for a file igb: Add lock to avoid data race fec: Fix timer capture timing in `fec_ptp_enable_pps()` i40e: Fix to stop tx_timeout recovery if GLOBR fails powerpc/pci: Fix get_phb_number() locking netfilter: nf_tables: really skip inactive sets when allocating name nios2: add force_successful_syscall_return() nios2: restarts apply only to the first sigframe we build... nios2: fix syscall restart checks nios2: traced syscall does need to check the syscall number nios2: don't leave NULLs in sys_call_table[] nios2: page fault et.al. are *not* restartable syscalls... atm: idt77252: fix use-after-free bugs caused by tst_timer xen/xenbus: fix return type in xenbus_file_read() NTB: ntb_tool: uninitialized heap data in tool_fn_write() tools build: Switch to new openssl API for test-libcrypto vsock: Set socket state back to SS_UNCONNECTED in vsock_connect_timeout() vsock: Fix memory leak in vsock_connect() geneve: do not use RT_TOS for IPv6 flowlabel ACPI: property: Return type of acpi_add_nondev_subnodes() should be bool pinctrl: qcom: msm8916: Allow CAMSS GP clocks to be muxed pinctrl: nomadik: Fix refcount leak in nmk_pinctrl_dt_subnode_to_map SUNRPC: Reinitialise the backchannel request buffers before reuse NFSv4/pnfs: Fix a use-after-free bug in open NFSv4.1: RECLAIM_COMPLETE must handle EACCES NFSv4: Fix races in the legacy idmapper upcall apparmor: Fix memleak in aa_simple_write_to_buffer() apparmor: fix reference count leak in aa_pivotroot() apparmor: fix overlapping attachment computation apparmor: fix aa_label_asxprint return check apparmor: Fix failed mount permission check error message apparmor: fix absroot causing audited secids to begin with = apparmor: fix quiet_denied for file rules can: ems_usb: fix clang's -Wunaligned-access warning tracing: Have filter accept "common_cpu" to be consistent btrfs: fix lost error handling when looking up extended ref on log replay mmc: pxamci: Fix an error handling path in pxamci_probe() mmc: pxamci: Fix another error handling path in pxamci_probe() ata: libata-eh: Add missing command name rds: add missing barrier to release_refill ALSA: info: Fix llseek return value when using callback powerpc/ptdump: Fix display of RW pages on FSL_BOOK3E powerpc/mm: Split dump_pagelinuxtables flag_array table firmware: arm_scpi: Ensure scpi_info is not assigned if the probe fails net_sched: cls_route: disallow handle of 0 net/9p: Initialize the iounit field during fid creation Bluetooth: L2CAP: Fix l2cap_global_chan_by_psm regression Revert "net: usb: ax88179_178a needs FLAG_SEND_ZLP" scsi: sg: Allow waiting for commands to complete on removed device tcp: fix over estimation in sk_forced_mem_schedule() KVM: x86: Avoid theoretical NULL pointer dereference in kvm_irq_delivery_to_apic_fast() KVM: x86: Check lapic_in_kernel() before attempting to set a SynIC irq KVM: Add infrastructure and macro to mark VM as bugged btrfs: reject log replay if there is unsupported RO compat flag net_sched: cls_route: remove from list when handle is 0 ACPI: CPPC: Do not prevent CPPC from working in the future dm writecache: set a default MAX_WRITEBACK_JOBS dm raid: fix address sanitizer warning in raid_status dm raid: fix address sanitizer warning in raid_resume intel_th: pci: Add Meteor Lake-P support intel_th: pci: Add Raptor Lake-S PCH support intel_th: pci: Add Raptor Lake-S CPU support ext4: correct the misjudgment in ext4_iget_extra_inode ext4: correct max_inline_xattr_value_size computing ext4: fix extent status tree race in writeback error recovery path ext4: update s_overhead_clusters in the superblock during an on-line resize ext4: fix use-after-free in ext4_xattr_set_entry ext4: make sure ext4_append() always allocates new block ext4: add EXT4_INODE_HAS_XATTR_SPACE macro in xattr.h spmi: trace: fix stack-out-of-bound access in SPMI tracing functions x86/olpc: fix 'logical not is only applied to the left hand side' scsi: zfcp: Fix missing auto port scan and thus missing target ports video: fbdev: s3fb: Check the size of screen before memset_io() video: fbdev: arkfb: Check the size of screen before memset_io() video: fbdev: vt8623fb: Check the size of screen before memset_io() tools/thermal: Fix possible path truncations video: fbdev: arkfb: Fix a divide-by-zero bug in ark_set_pixclock() x86/numa: Use cpumask_available instead of hardcoded NULL check scripts/faddr2line: Fix vmlinux detection on arm64 genelf: Use HAVE_LIBCRYPTO_SUPPORT, not the never defined HAVE_LIBCRYPTO powerpc/pci: Fix PHB numbering when using opal-phbid kprobes: Forbid probing on trampoline and BPF code areas powerpc/cell/axon_msi: Fix refcount leak in setup_msi_msg_address powerpc/xive: Fix refcount leak in xive_get_max_prio powerpc/spufs: Fix refcount leak in spufs_init_isolated_loader powerpc/pci: Prefer PCI domain assignment via DT 'linux,pci-domain' and alias powerpc/32: Do not allow selection of e5500 or e6500 CPUs on PPC32 video: fbdev: sis: fix typos in SiS_GetModeID() video: fbdev: amba-clcd: Fix refcount leak bugs ASoC: qcom: q6dsp: Fix an off-by-one in q6adm_alloc_copp() s390/zcore: fix race when reading from hardware system area iommu/arm-smmu: qcom_iommu: Add of_node_put() when breaking out of loop mfd: t7l66xb: Drop platform disable callback kfifo: fix kfifo_to_user() return type rpmsg: qcom_smd: Fix refcount leak in qcom_smd_parse_edge iommu/exynos: Handle failed IOMMU device registration properly tty: n_gsm: fix missing corner cases in gsmld_poll() tty: n_gsm: fix DM command tty: n_gsm: fix wrong T1 retry count handling vfio/ccw: Do not change FSM state in subchannel event remoteproc: qcom: wcnss: Fix handling of IRQs tty: n_gsm: fix race condition in gsmld_write() tty: n_gsm: fix packet re-transmission without open control channel tty: n_gsm: fix non flow control frames during mux flow off profiling: fix shift too large makes kernel panic serial: 8250_dw: Store LSR into lsr_saved_flags in dw8250_tx_wait_empty() ASoC: mediatek: mt8173-rt5650: Fix refcount leak in mt8173_rt5650_dev_probe ASoC: codecs: da7210: add check for i2c_add_driver ASoC: mt6797-mt6351: Fix refcount leak in mt6797_mt6351_dev_probe ASoC: mediatek: mt8173: Fix refcount leak in mt8173_rt5650_rt5676_dev_probe jbd2: fix assertion 'jh->b_frozen_data == NULL' failure when journal aborted ext4: recover csum seed of tmp_inode after migrating to extents null_blk: fix ida error handling in null_add_dev() RDMA/rxe: Fix error unwind in rxe_create_qp() mm/mmap.c: fix missing call to vm_unacct_memory in mmap_region platform/olpc: Fix uninitialized data in debugfs write USB: serial: fix tty-port initialized comments HID: alps: Declare U1_UNICORN_LEGACY support mmc: cavium-thunderx: Add of_node_put() when breaking out of loop mmc: cavium-octeon: Add of_node_put() when breaking out of loop gpio: gpiolib-of: Fix refcount bugs in of_mm_gpiochip_add_data() RDMA/hfi1: fix potential memory leak in setup_base_ctxt() usb: gadget: udc: amd5536 depends on HAS_DMA scsi: smartpqi: Fix DMA direction for RAID requests mmc: sdhci-of-at91: fix set_uhs_signaling rewriting of MC1R memstick/ms_block: Fix a memory leak memstick/ms_block: Fix some incorrect memory allocation mmc: sdhci-of-esdhc: Fix refcount leak in esdhc_signal_voltage_switch staging: rtl8192u: Fix sleep in atomic context bug in dm_fsync_timer_callback soundwire: bus_type: fix remove and shutdown support clk: qcom: ipq8074: set BRANCH_HALT_DELAY flag for UBI clocks clk: qcom: ipq8074: fix NSS port frequency tables misc: rtsx: Fix an error handling path in rtsx_pci_probe() usb: ohci-nxp: Fix refcount leak in ohci_hcd_nxp_probe usb: host: Fix refcount leak in ehci_hcd_ppc_of_probe fpga: altera-pr-ip: fix unsigned comparison with less than zero mtd: st_spi_fsm: Add a clk_disable_unprepare() in .probe()'s error path mtd: sm_ftl: Fix deadlock caused by cancel_work_sync in sm_release HID: cp2112: prevent a buffer overflow in cp2112_xfer() mtd: maps: Fix refcount leak in ap_flash_init mtd: maps: Fix refcount leak in of_flash_probe_versatile clk: renesas: r9a06g032: Fix UART clkgrp bitsel dccp: put dccp_qpolicy_full() and dccp_qpolicy_push() in the same lock net: rose: fix netdev reference changes netdevsim: Avoid allocation warnings triggered from user space net/mlx5e: Fix the value of MLX5E_MAX_RQ_NUM_MTTS wifi: libertas: Fix possible refcount leak in if_usb_probe() wifi: wil6210: debugfs: fix uninitialized variable use in `wil_write_file_wmi()` i2c: mux-gpmux: Add of_node_put() when breaking out of loop i2c: cadence: Support PEC for SMBus block read Bluetooth: hci_intel: Add check for platform_driver_register can: pch_can: pch_can_error(): initialize errc before using it can: error: specify the values of data[5..7] of CAN error frames can: usb_8dev: do not report txerr and rxerr during bus-off can: kvaser_usb_leaf: do not report txerr and rxerr during bus-off can: kvaser_usb_hydra: do not report txerr and rxerr during bus-off can: sun4i_can: do not report txerr and rxerr during bus-off can: hi311x: do not report txerr and rxerr during bus-off can: sja1000: do not report txerr and rxerr during bus-off can: rcar_can: do not report txerr and rxerr during bus-off can: pch_can: do not report txerr and rxerr during bus-off wifi: p54: add missing parentheses in p54_flush() wifi: p54: Fix an error handling path in p54spi_probe() selftests: timers: clocksource-switch: fix passing errors from child wifi: wil6210: debugfs: fix info leak in wil_write_file_wmi() selftests: timers: valid-adjtimex: build fix for newer toolchains fs: check FMODE_LSEEK to control internal pipe splicing libbpf: Fix the name of a reused map tcp: make retransmitted SKB fit into the send window mediatek: mt76: mac80211: Fix missing of_node_put() in mt76_led_init() media: platform: mtk-mdp: Fix mdp_ipi_comm structure alignment crypto: hisilicon - Kunpeng916 crypto driver don't sleep when in softirq Change-Id: I1a4bb33f07f7ac850e069a5ac664d668f42b377f Signed-off-by: UtsavBalar1231 <utsavbalar1231@gmail.com> Conflicts: drivers/usb/dwc3/core.c
824 lines
22 KiB
C
824 lines
22 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Detect hard and soft lockups on a system
|
|
*
|
|
* started by Don Zickus, Copyright (C) 2010 Red Hat, Inc.
|
|
*
|
|
* 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
|
|
* to those contributors as well.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "watchdog: " fmt
|
|
|
|
#include <linux/mm.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/device.h>
|
|
#include <linux/nmi.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/tick.h>
|
|
#include <linux/sched/clock.h>
|
|
#include <linux/sched/debug.h>
|
|
#include <linux/sched/isolation.h>
|
|
#include <linux/stop_machine.h>
|
|
|
|
#include <asm/irq_regs.h>
|
|
#include <linux/kvm_para.h>
|
|
|
|
static DEFINE_MUTEX(watchdog_mutex);
|
|
|
|
#if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HAVE_NMI_WATCHDOG)
|
|
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED | NMI_WATCHDOG_ENABLED)
|
|
# define NMI_WATCHDOG_DEFAULT 1
|
|
#else
|
|
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED)
|
|
# define NMI_WATCHDOG_DEFAULT 0
|
|
#endif
|
|
|
|
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;
|
|
int __read_mostly watchdog_thresh = 10;
|
|
int __read_mostly nmi_watchdog_available;
|
|
|
|
struct cpumask watchdog_allowed_mask __read_mostly;
|
|
|
|
struct cpumask watchdog_cpumask __read_mostly;
|
|
unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
|
|
|
|
#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().
|
|
*/
|
|
void __init hardlockup_detector_disable(void)
|
|
{
|
|
nmi_watchdog_user_enabled = 0;
|
|
}
|
|
|
|
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))
|
|
nmi_watchdog_user_enabled = 0;
|
|
else if (!strncmp(str, "1", 1))
|
|
nmi_watchdog_user_enabled = 1;
|
|
return 1;
|
|
}
|
|
__setup("nmi_watchdog=", hardlockup_panic_setup);
|
|
|
|
# ifdef CONFIG_SMP
|
|
int __read_mostly sysctl_hardlockup_all_cpu_backtrace;
|
|
|
|
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 */
|
|
|
|
/*
|
|
* These functions can be overridden if an architecture implements its
|
|
* own hardlockup detector.
|
|
*
|
|
* 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.
|
|
*/
|
|
int __weak watchdog_nmi_enable(unsigned int cpu)
|
|
{
|
|
hardlockup_detector_perf_enable();
|
|
return 0;
|
|
}
|
|
|
|
void __weak watchdog_nmi_disable(unsigned int cpu)
|
|
{
|
|
hardlockup_detector_perf_disable();
|
|
}
|
|
|
|
/* Return 0, if a NMI watchdog is available. Error code otherwise */
|
|
int __weak __init watchdog_nmi_probe(void)
|
|
{
|
|
return hardlockup_detector_perf_init();
|
|
}
|
|
|
|
/**
|
|
* watchdog_nmi_stop - Stop the watchdog for reconfiguration
|
|
*
|
|
* The reconfiguration steps are:
|
|
* watchdog_nmi_stop();
|
|
* update_variables();
|
|
* watchdog_nmi_start();
|
|
*/
|
|
void __weak watchdog_nmi_stop(void) { }
|
|
|
|
/**
|
|
* watchdog_nmi_start - Start the watchdog after reconfiguration
|
|
*
|
|
* Counterpart to watchdog_nmi_stop().
|
|
*
|
|
* The following variables have been updated in update_variables() and
|
|
* contain the currently valid configuration:
|
|
* - watchdog_enabled
|
|
* - watchdog_thresh
|
|
* - watchdog_cpumask
|
|
*/
|
|
void __weak watchdog_nmi_start(void) { }
|
|
|
|
/**
|
|
* 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;
|
|
if (nmi_watchdog_available && nmi_watchdog_user_enabled)
|
|
watchdog_enabled |= NMI_WATCHDOG_ENABLED;
|
|
if (soft_watchdog_user_enabled)
|
|
watchdog_enabled |= SOFT_WATCHDOG_ENABLED;
|
|
}
|
|
|
|
#ifdef CONFIG_SOFTLOCKUP_DETECTOR
|
|
|
|
#define SOFTLOCKUP_RESET ULONG_MAX
|
|
|
|
/* Global variables, exported for sysctl */
|
|
unsigned int __read_mostly softlockup_panic =
|
|
CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
|
|
|
|
static bool softlockup_initialized __read_mostly;
|
|
static u64 __read_mostly sample_period;
|
|
|
|
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
|
|
static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);
|
|
static DEFINE_PER_CPU(unsigned int, watchdog_en);
|
|
static DEFINE_PER_CPU(bool, softlockup_touch_sync);
|
|
static DEFINE_PER_CPU(bool, soft_watchdog_warn);
|
|
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);
|
|
static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt);
|
|
static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved);
|
|
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
|
|
static unsigned long soft_lockup_nmi_warn;
|
|
|
|
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)
|
|
{
|
|
watchdog_user_enabled = 0;
|
|
return 1;
|
|
}
|
|
__setup("nowatchdog", nowatchdog_setup);
|
|
|
|
static int __init nosoftlockup_setup(char *str)
|
|
{
|
|
soft_watchdog_user_enabled = 0;
|
|
return 1;
|
|
}
|
|
__setup("nosoftlockup", nosoftlockup_setup);
|
|
|
|
#ifdef CONFIG_SMP
|
|
int __read_mostly sysctl_softlockup_all_cpu_backtrace;
|
|
|
|
static int __init softlockup_all_cpu_backtrace_setup(char *str)
|
|
{
|
|
sysctl_softlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0);
|
|
return 1;
|
|
}
|
|
__setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);
|
|
#endif
|
|
|
|
static void __lockup_detector_cleanup(void);
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
static int get_softlockup_thresh(void)
|
|
{
|
|
return watchdog_thresh * 2;
|
|
}
|
|
|
|
/*
|
|
* Returns seconds, approximately. We don't need nanosecond
|
|
* resolution, and we don't need to waste time with a big divide when
|
|
* 2^30ns == 1.074s.
|
|
*/
|
|
static unsigned long get_timestamp(void)
|
|
{
|
|
return running_clock() >> 30LL; /* 2^30 ~= 10^9 */
|
|
}
|
|
|
|
static void set_sample_period(void)
|
|
{
|
|
/*
|
|
* convert watchdog_thresh from seconds to ns
|
|
* 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
|
|
*/
|
|
sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5);
|
|
watchdog_update_hrtimer_threshold(sample_period);
|
|
}
|
|
|
|
/* Commands for resetting the watchdog */
|
|
static void __touch_watchdog(void)
|
|
{
|
|
__this_cpu_write(watchdog_touch_ts, get_timestamp());
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
notrace void touch_softlockup_watchdog_sched(void)
|
|
{
|
|
/*
|
|
* Preemption can be enabled. It doesn't matter which CPU's timestamp
|
|
* gets zeroed here, so use the raw_ operation.
|
|
*/
|
|
raw_cpu_write(watchdog_touch_ts, SOFTLOCKUP_RESET);
|
|
}
|
|
|
|
notrace void touch_softlockup_watchdog(void)
|
|
{
|
|
touch_softlockup_watchdog_sched();
|
|
wq_watchdog_touch(raw_smp_processor_id());
|
|
}
|
|
EXPORT_SYMBOL(touch_softlockup_watchdog);
|
|
|
|
void touch_all_softlockup_watchdogs(void)
|
|
{
|
|
int cpu;
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
for_each_cpu(cpu, &watchdog_allowed_mask)
|
|
per_cpu(watchdog_touch_ts, cpu) = SOFTLOCKUP_RESET;
|
|
wq_watchdog_touch(-1);
|
|
}
|
|
|
|
void touch_softlockup_watchdog_sync(void)
|
|
{
|
|
__this_cpu_write(softlockup_touch_sync, true);
|
|
__this_cpu_write(watchdog_touch_ts, SOFTLOCKUP_RESET);
|
|
}
|
|
|
|
static int is_softlockup(unsigned long touch_ts)
|
|
{
|
|
unsigned long now = get_timestamp();
|
|
|
|
if ((watchdog_enabled & SOFT_WATCHDOG_ENABLED) && watchdog_thresh){
|
|
/* Warn about unreasonable delays. */
|
|
if (time_after(now, touch_ts + get_softlockup_thresh()))
|
|
return now - touch_ts;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* watchdog detector functions */
|
|
bool is_hardlockup(void)
|
|
{
|
|
unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
|
|
|
|
if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
|
|
return true;
|
|
|
|
__this_cpu_write(hrtimer_interrupts_saved, hrint);
|
|
return false;
|
|
}
|
|
|
|
static void watchdog_interrupt_count(void)
|
|
{
|
|
__this_cpu_inc(hrtimer_interrupts);
|
|
}
|
|
|
|
static DEFINE_PER_CPU(struct completion, softlockup_completion);
|
|
static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work);
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
__this_cpu_write(soft_lockup_hrtimer_cnt,
|
|
__this_cpu_read(hrtimer_interrupts));
|
|
__touch_watchdog();
|
|
complete(this_cpu_ptr(&softlockup_completion));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* watchdog kicker functions */
|
|
static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
|
|
{
|
|
unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);
|
|
struct pt_regs *regs = get_irq_regs();
|
|
int duration;
|
|
int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;
|
|
|
|
if (!watchdog_enabled)
|
|
return HRTIMER_NORESTART;
|
|
|
|
/* kick the hardlockup detector */
|
|
watchdog_interrupt_count();
|
|
|
|
/* kick the softlockup detector */
|
|
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));
|
|
}
|
|
|
|
/* .. and repeat */
|
|
hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));
|
|
|
|
if (touch_ts == SOFTLOCKUP_RESET) {
|
|
if (unlikely(__this_cpu_read(softlockup_touch_sync))) {
|
|
/*
|
|
* If the time stamp was touched atomically
|
|
* make sure the scheduler tick is up to date.
|
|
*/
|
|
__this_cpu_write(softlockup_touch_sync, false);
|
|
sched_clock_tick();
|
|
}
|
|
|
|
/* Clear the guest paused flag on watchdog reset */
|
|
kvm_check_and_clear_guest_paused();
|
|
__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
|
|
*/
|
|
duration = is_softlockup(touch_ts);
|
|
if (unlikely(duration)) {
|
|
/*
|
|
* 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;
|
|
|
|
/* only warn once */
|
|
if (__this_cpu_read(soft_watchdog_warn) == true) {
|
|
/*
|
|
* When multiple processes are causing softlockups the
|
|
* softlockup detector only warns on the first one
|
|
* because the code relies on a full quiet cycle to
|
|
* re-arm. The second process prevents the quiet cycle
|
|
* and never gets reported. Use task pointers to detect
|
|
* this.
|
|
*/
|
|
if (__this_cpu_read(softlockup_task_ptr_saved) !=
|
|
current) {
|
|
__this_cpu_write(soft_watchdog_warn, false);
|
|
__touch_watchdog();
|
|
}
|
|
return HRTIMER_RESTART;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
|
|
smp_processor_id(), duration,
|
|
current->comm, task_pid_nr(current));
|
|
__this_cpu_write(softlockup_task_ptr_saved, current);
|
|
print_modules();
|
|
print_irqtrace_events(current);
|
|
if (regs)
|
|
show_regs(regs);
|
|
else
|
|
dump_stack();
|
|
|
|
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();
|
|
}
|
|
|
|
add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK);
|
|
if (softlockup_panic)
|
|
panic("softlockup: hung tasks");
|
|
__this_cpu_write(soft_watchdog_warn, true);
|
|
} else
|
|
__this_cpu_write(soft_watchdog_warn, false);
|
|
|
|
return HRTIMER_RESTART;
|
|
}
|
|
|
|
void watchdog_enable(unsigned int cpu)
|
|
{
|
|
struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);
|
|
struct completion *done = this_cpu_ptr(&softlockup_completion);
|
|
unsigned int *enabled = this_cpu_ptr(&watchdog_en);
|
|
|
|
WARN_ON_ONCE(cpu != smp_processor_id());
|
|
|
|
init_completion(done);
|
|
complete(done);
|
|
|
|
if (*enabled)
|
|
return;
|
|
|
|
/*
|
|
* Start the timer first to prevent the NMI watchdog triggering
|
|
* before the timer has a chance to fire.
|
|
*/
|
|
hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
hrtimer->function = watchdog_timer_fn;
|
|
hrtimer_start(hrtimer, ns_to_ktime(sample_period),
|
|
HRTIMER_MODE_REL_PINNED);
|
|
|
|
/* Initialize timestamp */
|
|
__touch_watchdog();
|
|
/* Enable the perf event */
|
|
if (watchdog_enabled & NMI_WATCHDOG_ENABLED)
|
|
watchdog_nmi_enable(cpu);
|
|
|
|
/*
|
|
* Need to ensure above operations are observed by other CPUs before
|
|
* indicating that timer is enabled. This is to synchronize core
|
|
* isolation and hotplug. Core isolation will wait for this flag to be
|
|
* set.
|
|
*/
|
|
mb();
|
|
*enabled = 1;
|
|
}
|
|
|
|
void watchdog_disable(unsigned int cpu)
|
|
{
|
|
struct hrtimer *hrtimer = per_cpu_ptr(&watchdog_hrtimer, cpu);
|
|
unsigned int *enabled = per_cpu_ptr(&watchdog_en, cpu);
|
|
|
|
if (!*enabled)
|
|
return;
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
watchdog_nmi_disable(cpu);
|
|
hrtimer_cancel(hrtimer);
|
|
wait_for_completion(per_cpu_ptr(&softlockup_completion, cpu));
|
|
|
|
/*
|
|
* No need for barrier here since disabling the watchdog is
|
|
* synchronized with hotplug lock
|
|
*/
|
|
*enabled = 0;
|
|
}
|
|
|
|
bool watchdog_configured(unsigned int cpu)
|
|
{
|
|
return *per_cpu_ptr(&watchdog_en, cpu);
|
|
}
|
|
|
|
static int softlockup_stop_fn(void *data)
|
|
{
|
|
watchdog_disable(smp_processor_id());
|
|
return 0;
|
|
}
|
|
|
|
static void softlockup_stop_all(void)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static int softlockup_start_fn(void *data)
|
|
{
|
|
watchdog_enable(smp_processor_id());
|
|
return 0;
|
|
}
|
|
|
|
static void softlockup_start_all(void)
|
|
{
|
|
int cpu;
|
|
|
|
cpumask_copy(&watchdog_allowed_mask, &watchdog_cpumask);
|
|
for_each_cpu(cpu, &watchdog_allowed_mask)
|
|
smp_call_on_cpu(cpu, softlockup_start_fn, NULL, false);
|
|
}
|
|
|
|
int lockup_detector_online_cpu(unsigned int cpu)
|
|
{
|
|
if (cpumask_test_cpu(cpu, &watchdog_allowed_mask))
|
|
watchdog_enable(cpu);
|
|
return 0;
|
|
}
|
|
|
|
int lockup_detector_offline_cpu(unsigned int cpu)
|
|
{
|
|
if (cpumask_test_cpu(cpu, &watchdog_allowed_mask))
|
|
watchdog_disable(cpu);
|
|
return 0;
|
|
}
|
|
|
|
static void __lockup_detector_reconfigure(void)
|
|
{
|
|
cpus_read_lock();
|
|
watchdog_nmi_stop();
|
|
|
|
softlockup_stop_all();
|
|
set_sample_period();
|
|
lockup_detector_update_enable();
|
|
if (watchdog_enabled && watchdog_thresh)
|
|
softlockup_start_all();
|
|
|
|
watchdog_nmi_start();
|
|
cpus_read_unlock();
|
|
/*
|
|
* Must be called outside the cpus locked section to prevent
|
|
* recursive locking in the perf code.
|
|
*/
|
|
__lockup_detector_cleanup();
|
|
}
|
|
|
|
void lockup_detector_reconfigure(void)
|
|
{
|
|
mutex_lock(&watchdog_mutex);
|
|
__lockup_detector_reconfigure();
|
|
mutex_unlock(&watchdog_mutex);
|
|
}
|
|
|
|
/*
|
|
* Create the watchdog thread infrastructure and configure the detector(s).
|
|
*
|
|
* The threads are not unparked as watchdog_allowed_mask is empty. When
|
|
* the threads are sucessfully initialized, take the proper locks and
|
|
* unpark the threads in the watchdog_cpumask if the watchdog is enabled.
|
|
*/
|
|
static __init void lockup_detector_setup(void)
|
|
{
|
|
/*
|
|
* If sysctl is off and watchdog got disabled on the command line,
|
|
* nothing to do here.
|
|
*/
|
|
lockup_detector_update_enable();
|
|
|
|
if (!IS_ENABLED(CONFIG_SYSCTL) &&
|
|
!(watchdog_enabled && watchdog_thresh))
|
|
return;
|
|
|
|
mutex_lock(&watchdog_mutex);
|
|
__lockup_detector_reconfigure();
|
|
softlockup_initialized = true;
|
|
mutex_unlock(&watchdog_mutex);
|
|
}
|
|
|
|
#else /* CONFIG_SOFTLOCKUP_DETECTOR */
|
|
static void __lockup_detector_reconfigure(void)
|
|
{
|
|
cpus_read_lock();
|
|
watchdog_nmi_stop();
|
|
lockup_detector_update_enable();
|
|
watchdog_nmi_start();
|
|
cpus_read_unlock();
|
|
}
|
|
void lockup_detector_reconfigure(void)
|
|
{
|
|
__lockup_detector_reconfigure();
|
|
}
|
|
static inline void lockup_detector_setup(void)
|
|
{
|
|
__lockup_detector_reconfigure();
|
|
}
|
|
#endif /* !CONFIG_SOFTLOCKUP_DETECTOR */
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
/* Propagate any changes to the watchdog threads */
|
|
static void proc_watchdog_update(void)
|
|
{
|
|
/* Remove impossible cpus to keep sysctl output clean. */
|
|
cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask);
|
|
__lockup_detector_reconfigure();
|
|
}
|
|
|
|
/*
|
|
* common function for watchdog, nmi_watchdog and soft_watchdog parameter
|
|
*
|
|
* 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
|
|
*/
|
|
static int proc_watchdog_common(int which, struct ctl_table *table, int write,
|
|
void __user *buffer, size_t *lenp, loff_t *ppos)
|
|
{
|
|
int err, old, *param = table->data;
|
|
|
|
mutex_lock(&watchdog_mutex);
|
|
|
|
if (!write) {
|
|
/*
|
|
* On read synchronize the userspace interface. This is a
|
|
* racy snapshot.
|
|
*/
|
|
*param = (watchdog_enabled & which) != 0;
|
|
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
|
|
} else {
|
|
old = READ_ONCE(*param);
|
|
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
|
|
if (!err && old != READ_ONCE(*param))
|
|
proc_watchdog_update();
|
|
}
|
|
mutex_unlock(&watchdog_mutex);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* /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
|
|
*/
|
|
int proc_nmi_watchdog(struct ctl_table *table, int write,
|
|
void __user *buffer, size_t *lenp, loff_t *ppos)
|
|
{
|
|
if (!nmi_watchdog_available && write)
|
|
return -ENOTSUPP;
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* /proc/sys/kernel/watchdog_thresh
|
|
*/
|
|
int proc_watchdog_thresh(struct ctl_table *table, int write,
|
|
void __user *buffer, size_t *lenp, loff_t *ppos)
|
|
{
|
|
int err, old;
|
|
|
|
mutex_lock(&watchdog_mutex);
|
|
|
|
old = READ_ONCE(watchdog_thresh);
|
|
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
|
|
|
|
if (!err && write && old != READ_ONCE(watchdog_thresh))
|
|
proc_watchdog_update();
|
|
|
|
mutex_unlock(&watchdog_mutex);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
|
|
mutex_lock(&watchdog_mutex);
|
|
|
|
err = proc_do_large_bitmap(table, write, buffer, lenp, ppos);
|
|
if (!err && write)
|
|
proc_watchdog_update();
|
|
|
|
mutex_unlock(&watchdog_mutex);
|
|
return err;
|
|
}
|
|
#endif /* CONFIG_SYSCTL */
|
|
|
|
void __init lockup_detector_init(void)
|
|
{
|
|
if (tick_nohz_full_enabled())
|
|
pr_info("Disabling watchdog on nohz_full cores by default\n");
|
|
|
|
cpumask_copy(&watchdog_cpumask,
|
|
housekeeping_cpumask(HK_FLAG_TIMER));
|
|
|
|
if (!watchdog_nmi_probe())
|
|
nmi_watchdog_available = true;
|
|
lockup_detector_setup();
|
|
}
|