This is the 4.19-rc6 release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAluw4MIACgkQONu9yGCS
aT7+8xAAiYnc4khUsxeInm3z44WPfRX1+UF51frTNSY5C8Nn5nvRSnTUNLuKkkrz
8RbwCL6UYyJxF9I/oZdHPsPOD4IxXkQY55tBjz7ZbSBIFEwYM6RJMm8mAGlXY7wq
VyWA5MhlpGHM9DjrguB4DMRipnrSc06CVAnC+ZyKLjzblzU1Wdf2dYu+AW9pUVXP
j4r74lFED5djPY1xfqfzEwmYRCeEGYGx7zMqT3GrrF5uFPqj1H6O5klEsAhIZvdl
IWnJTU2coC8R/Sd17g4lHWPIeQNnMUGIUbu+PhIrZ/lDwFxlocg4BvarPXEdzgYi
gdZzKBfovpEsSu5RCQsKWG4IGQxY7I1p70IOP9eqEFHZy77qT1YcHVAWrK1Y/bJd
UA08gUOSzRnhKkNR3+PsaMflUOl9WkpyHECZu394cyRGMutSS50aWkavJPJ/o1Qi
D/oGqZLLcKFyuNcchG+Met1TzY3LvYEDgSburqwqeUZWtAsGs8kmiiq7qvmXx4zV
IcgM8ERqJ8mbfhfsXQU7hwydIrPJ3JdIq19RnM5ajbv2Q4C/qJCyAKkQoacrlKR4
aiow/qvyNrP80rpXfPJB8/8PiWeDtAnnGhM+xySZNlw3t8GR6NYpUkIzf5TdkSb3
C8KuKg6FY9QAS62fv+5KK3LB/wbQanxaPNruQFGe5K1iDQ5Fvzw=
=dMl4
-----END PGP SIGNATURE-----
Merge tag 'v4.19-rc6' into for-4.20/block
Merge -rc6 in, for two reasons:
1) Resolve a trivial conflict in the blk-mq-tag.c documentation
2) A few important regression fixes went into upstream directly, so
they aren't in the 4.20 branch.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
* tag 'v4.19-rc6': (780 commits)
Linux 4.19-rc6
MAINTAINERS: fix reference to moved drivers/{misc => auxdisplay}/panel.c
cpufreq: qcom-kryo: Fix section annotations
perf/core: Add sanity check to deal with pinned event failure
xen/blkfront: correct purging of persistent grants
Revert "xen/blkfront: When purging persistent grants, keep them in the buffer"
selftests/powerpc: Fix Makefiles for headers_install change
blk-mq: I/O and timer unplugs are inverted in blktrace
dax: Fix deadlock in dax_lock_mapping_entry()
x86/boot: Fix kexec booting failure in the SEV bit detection code
bcache: add separate workqueue for journal_write to avoid deadlock
drm/amd/display: Fix Edid emulation for linux
drm/amd/display: Fix Vega10 lightup on S3 resume
drm/amdgpu: Fix vce work queue was not cancelled when suspend
Revert "drm/panel: Add device_link from panel device to DRM device"
xen/blkfront: When purging persistent grants, keep them in the buffer
clocksource/drivers/timer-atmel-pit: Properly handle error cases
block: fix deadline elevator drain for zoned block devices
ACPI / hotplug / PCI: Don't scan for non-hotplug bridges if slot is not bridge
drm/syncobj: Don't leak fences when WAIT_FOR_SUBMIT is set
...
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Jens Axboe
commit
c0aac682fa
846 changed files with 8136 additions and 4592 deletions
|
|
@ -1844,7 +1844,7 @@ static int btf_check_all_metas(struct btf_verifier_env *env)
|
|||
|
||||
hdr = &btf->hdr;
|
||||
cur = btf->nohdr_data + hdr->type_off;
|
||||
end = btf->nohdr_data + hdr->type_len;
|
||||
end = cur + hdr->type_len;
|
||||
|
||||
env->log_type_id = 1;
|
||||
while (cur < end) {
|
||||
|
|
|
|||
|
|
@ -132,6 +132,7 @@ struct smap_psock {
|
|||
struct work_struct gc_work;
|
||||
|
||||
struct proto *sk_proto;
|
||||
void (*save_unhash)(struct sock *sk);
|
||||
void (*save_close)(struct sock *sk, long timeout);
|
||||
void (*save_data_ready)(struct sock *sk);
|
||||
void (*save_write_space)(struct sock *sk);
|
||||
|
|
@ -143,6 +144,7 @@ static int bpf_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
|
|||
static int bpf_tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size);
|
||||
static int bpf_tcp_sendpage(struct sock *sk, struct page *page,
|
||||
int offset, size_t size, int flags);
|
||||
static void bpf_tcp_unhash(struct sock *sk);
|
||||
static void bpf_tcp_close(struct sock *sk, long timeout);
|
||||
|
||||
static inline struct smap_psock *smap_psock_sk(const struct sock *sk)
|
||||
|
|
@ -184,6 +186,7 @@ static void build_protos(struct proto prot[SOCKMAP_NUM_CONFIGS],
|
|||
struct proto *base)
|
||||
{
|
||||
prot[SOCKMAP_BASE] = *base;
|
||||
prot[SOCKMAP_BASE].unhash = bpf_tcp_unhash;
|
||||
prot[SOCKMAP_BASE].close = bpf_tcp_close;
|
||||
prot[SOCKMAP_BASE].recvmsg = bpf_tcp_recvmsg;
|
||||
prot[SOCKMAP_BASE].stream_memory_read = bpf_tcp_stream_read;
|
||||
|
|
@ -217,6 +220,7 @@ static int bpf_tcp_init(struct sock *sk)
|
|||
return -EBUSY;
|
||||
}
|
||||
|
||||
psock->save_unhash = sk->sk_prot->unhash;
|
||||
psock->save_close = sk->sk_prot->close;
|
||||
psock->sk_proto = sk->sk_prot;
|
||||
|
||||
|
|
@ -305,30 +309,12 @@ static struct smap_psock_map_entry *psock_map_pop(struct sock *sk,
|
|||
return e;
|
||||
}
|
||||
|
||||
static void bpf_tcp_close(struct sock *sk, long timeout)
|
||||
static void bpf_tcp_remove(struct sock *sk, struct smap_psock *psock)
|
||||
{
|
||||
void (*close_fun)(struct sock *sk, long timeout);
|
||||
struct smap_psock_map_entry *e;
|
||||
struct sk_msg_buff *md, *mtmp;
|
||||
struct smap_psock *psock;
|
||||
struct sock *osk;
|
||||
|
||||
lock_sock(sk);
|
||||
rcu_read_lock();
|
||||
psock = smap_psock_sk(sk);
|
||||
if (unlikely(!psock)) {
|
||||
rcu_read_unlock();
|
||||
release_sock(sk);
|
||||
return sk->sk_prot->close(sk, timeout);
|
||||
}
|
||||
|
||||
/* The psock may be destroyed anytime after exiting the RCU critial
|
||||
* section so by the time we use close_fun the psock may no longer
|
||||
* be valid. However, bpf_tcp_close is called with the sock lock
|
||||
* held so the close hook and sk are still valid.
|
||||
*/
|
||||
close_fun = psock->save_close;
|
||||
|
||||
if (psock->cork) {
|
||||
free_start_sg(psock->sock, psock->cork, true);
|
||||
kfree(psock->cork);
|
||||
|
|
@ -379,6 +365,42 @@ static void bpf_tcp_close(struct sock *sk, long timeout)
|
|||
kfree(e);
|
||||
e = psock_map_pop(sk, psock);
|
||||
}
|
||||
}
|
||||
|
||||
static void bpf_tcp_unhash(struct sock *sk)
|
||||
{
|
||||
void (*unhash_fun)(struct sock *sk);
|
||||
struct smap_psock *psock;
|
||||
|
||||
rcu_read_lock();
|
||||
psock = smap_psock_sk(sk);
|
||||
if (unlikely(!psock)) {
|
||||
rcu_read_unlock();
|
||||
if (sk->sk_prot->unhash)
|
||||
sk->sk_prot->unhash(sk);
|
||||
return;
|
||||
}
|
||||
unhash_fun = psock->save_unhash;
|
||||
bpf_tcp_remove(sk, psock);
|
||||
rcu_read_unlock();
|
||||
unhash_fun(sk);
|
||||
}
|
||||
|
||||
static void bpf_tcp_close(struct sock *sk, long timeout)
|
||||
{
|
||||
void (*close_fun)(struct sock *sk, long timeout);
|
||||
struct smap_psock *psock;
|
||||
|
||||
lock_sock(sk);
|
||||
rcu_read_lock();
|
||||
psock = smap_psock_sk(sk);
|
||||
if (unlikely(!psock)) {
|
||||
rcu_read_unlock();
|
||||
release_sock(sk);
|
||||
return sk->sk_prot->close(sk, timeout);
|
||||
}
|
||||
close_fun = psock->save_close;
|
||||
bpf_tcp_remove(sk, psock);
|
||||
rcu_read_unlock();
|
||||
release_sock(sk);
|
||||
close_fun(sk, timeout);
|
||||
|
|
@ -2097,8 +2119,12 @@ static int sock_map_update_elem(struct bpf_map *map,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* ULPs are currently supported only for TCP sockets in ESTABLISHED
|
||||
* state.
|
||||
*/
|
||||
if (skops.sk->sk_type != SOCK_STREAM ||
|
||||
skops.sk->sk_protocol != IPPROTO_TCP) {
|
||||
skops.sk->sk_protocol != IPPROTO_TCP ||
|
||||
skops.sk->sk_state != TCP_ESTABLISHED) {
|
||||
fput(socket->file);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
|
@ -2453,6 +2479,16 @@ static int sock_hash_update_elem(struct bpf_map *map,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* ULPs are currently supported only for TCP sockets in ESTABLISHED
|
||||
* state.
|
||||
*/
|
||||
if (skops.sk->sk_type != SOCK_STREAM ||
|
||||
skops.sk->sk_protocol != IPPROTO_TCP ||
|
||||
skops.sk->sk_state != TCP_ESTABLISHED) {
|
||||
fput(socket->file);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
lock_sock(skops.sk);
|
||||
preempt_disable();
|
||||
rcu_read_lock();
|
||||
|
|
@ -2543,10 +2579,22 @@ const struct bpf_map_ops sock_hash_ops = {
|
|||
.map_check_btf = map_check_no_btf,
|
||||
};
|
||||
|
||||
static bool bpf_is_valid_sock_op(struct bpf_sock_ops_kern *ops)
|
||||
{
|
||||
return ops->op == BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB ||
|
||||
ops->op == BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB;
|
||||
}
|
||||
BPF_CALL_4(bpf_sock_map_update, struct bpf_sock_ops_kern *, bpf_sock,
|
||||
struct bpf_map *, map, void *, key, u64, flags)
|
||||
{
|
||||
WARN_ON_ONCE(!rcu_read_lock_held());
|
||||
|
||||
/* ULPs are currently supported only for TCP sockets in ESTABLISHED
|
||||
* state. This checks that the sock ops triggering the update is
|
||||
* one indicating we are (or will be soon) in an ESTABLISHED state.
|
||||
*/
|
||||
if (!bpf_is_valid_sock_op(bpf_sock))
|
||||
return -EOPNOTSUPP;
|
||||
return sock_map_ctx_update_elem(bpf_sock, map, key, flags);
|
||||
}
|
||||
|
||||
|
|
@ -2565,6 +2613,9 @@ BPF_CALL_4(bpf_sock_hash_update, struct bpf_sock_ops_kern *, bpf_sock,
|
|||
struct bpf_map *, map, void *, key, u64, flags)
|
||||
{
|
||||
WARN_ON_ONCE(!rcu_read_lock_held());
|
||||
|
||||
if (!bpf_is_valid_sock_op(bpf_sock))
|
||||
return -EOPNOTSUPP;
|
||||
return sock_hash_ctx_update_elem(bpf_sock, map, key, flags);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3163,7 +3163,7 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env,
|
|||
* an arbitrary scalar. Disallow all math except
|
||||
* pointer subtraction
|
||||
*/
|
||||
if (opcode == BPF_SUB){
|
||||
if (opcode == BPF_SUB && env->allow_ptr_leaks) {
|
||||
mark_reg_unknown(env, regs, insn->dst_reg);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
11
kernel/cpu.c
11
kernel/cpu.c
|
|
@ -607,15 +607,15 @@ static void cpuhp_thread_fun(unsigned int cpu)
|
|||
bool bringup = st->bringup;
|
||||
enum cpuhp_state state;
|
||||
|
||||
if (WARN_ON_ONCE(!st->should_run))
|
||||
return;
|
||||
|
||||
/*
|
||||
* ACQUIRE for the cpuhp_should_run() load of ->should_run. Ensures
|
||||
* that if we see ->should_run we also see the rest of the state.
|
||||
*/
|
||||
smp_mb();
|
||||
|
||||
if (WARN_ON_ONCE(!st->should_run))
|
||||
return;
|
||||
|
||||
cpuhp_lock_acquire(bringup);
|
||||
|
||||
if (st->single) {
|
||||
|
|
@ -916,7 +916,8 @@ static int cpuhp_down_callbacks(unsigned int cpu, struct cpuhp_cpu_state *st,
|
|||
ret = cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
|
||||
if (ret) {
|
||||
st->target = prev_state;
|
||||
undo_cpu_down(cpu, st);
|
||||
if (st->state < prev_state)
|
||||
undo_cpu_down(cpu, st);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -969,7 +970,7 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,
|
|||
* to do the further cleanups.
|
||||
*/
|
||||
ret = cpuhp_down_callbacks(cpu, st, target);
|
||||
if (ret && st->state > CPUHP_TEARDOWN_CPU && st->state < prev_state) {
|
||||
if (ret && st->state == CPUHP_TEARDOWN_CPU && st->state < prev_state) {
|
||||
cpuhp_reset_state(st, prev_state);
|
||||
__cpuhp_kick_ap(st);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,9 @@ config ARCH_HAS_SYNC_DMA_FOR_CPU
|
|||
bool
|
||||
select NEED_DMA_MAP_STATE
|
||||
|
||||
config ARCH_HAS_SYNC_DMA_FOR_CPU_ALL
|
||||
bool
|
||||
|
||||
config DMA_DIRECT_OPS
|
||||
bool
|
||||
depends on HAS_DMA
|
||||
|
|
|
|||
|
|
@ -2867,16 +2867,11 @@ static int perf_event_modify_breakpoint(struct perf_event *bp,
|
|||
_perf_event_disable(bp);
|
||||
|
||||
err = modify_user_hw_breakpoint_check(bp, attr, true);
|
||||
if (err) {
|
||||
if (!bp->attr.disabled)
|
||||
_perf_event_enable(bp);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!attr->disabled)
|
||||
if (!bp->attr.disabled)
|
||||
_perf_event_enable(bp);
|
||||
return 0;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int perf_event_modify_attr(struct perf_event *event,
|
||||
|
|
@ -3940,6 +3935,12 @@ int perf_event_read_local(struct perf_event *event, u64 *value,
|
|||
goto out;
|
||||
}
|
||||
|
||||
/* If this is a pinned event it must be running on this CPU */
|
||||
if (event->attr.pinned && event->oncpu != smp_processor_id()) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the event is currently on this CPU, its either a per-task event,
|
||||
* or local to this CPU. Furthermore it means its ACTIVE (otherwise
|
||||
|
|
@ -5948,6 +5949,7 @@ perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size,
|
|||
unsigned long sp;
|
||||
unsigned int rem;
|
||||
u64 dyn_size;
|
||||
mm_segment_t fs;
|
||||
|
||||
/*
|
||||
* We dump:
|
||||
|
|
@ -5965,7 +5967,10 @@ perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size,
|
|||
|
||||
/* Data. */
|
||||
sp = perf_user_stack_pointer(regs);
|
||||
fs = get_fs();
|
||||
set_fs(USER_DS);
|
||||
rem = __output_copy_user(handle, (void *) sp, dump_size);
|
||||
set_fs(fs);
|
||||
dyn_size = dump_size - rem;
|
||||
|
||||
perf_output_skip(handle, rem);
|
||||
|
|
|
|||
|
|
@ -509,6 +509,8 @@ modify_user_hw_breakpoint_check(struct perf_event *bp, struct perf_event_attr *a
|
|||
*/
|
||||
int modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr)
|
||||
{
|
||||
int err;
|
||||
|
||||
/*
|
||||
* modify_user_hw_breakpoint can be invoked with IRQs disabled and hence it
|
||||
* will not be possible to raise IPIs that invoke __perf_event_disable.
|
||||
|
|
@ -520,15 +522,12 @@ int modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *att
|
|||
else
|
||||
perf_event_disable(bp);
|
||||
|
||||
if (!attr->disabled) {
|
||||
int err = modify_user_hw_breakpoint_check(bp, attr, false);
|
||||
err = modify_user_hw_breakpoint_check(bp, attr, false);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
if (!bp->attr.disabled)
|
||||
perf_event_enable(bp);
|
||||
bp->attr.disabled = 0;
|
||||
}
|
||||
return 0;
|
||||
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(modify_user_hw_breakpoint);
|
||||
|
||||
|
|
|
|||
|
|
@ -678,7 +678,7 @@ jump_label_module_notify(struct notifier_block *self, unsigned long val,
|
|||
case MODULE_STATE_COMING:
|
||||
ret = jump_label_add_module(mod);
|
||||
if (ret) {
|
||||
WARN(1, "Failed to allocatote memory: jump_label may not work properly.\n");
|
||||
WARN(1, "Failed to allocate memory: jump_label may not work properly.\n");
|
||||
jump_label_del_module(mod);
|
||||
}
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -55,7 +55,6 @@
|
|||
|
||||
#include "lockdep_internals.h"
|
||||
|
||||
#include <trace/events/preemptirq.h>
|
||||
#define CREATE_TRACE_POINTS
|
||||
#include <trace/events/lock.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -389,7 +389,7 @@ static bool __ww_mutex_wound(struct mutex *lock,
|
|||
/*
|
||||
* wake_up_process() paired with set_current_state()
|
||||
* inserts sufficient barriers to make sure @owner either sees
|
||||
* it's wounded in __ww_mutex_lock_check_stamp() or has a
|
||||
* it's wounded in __ww_mutex_check_kill() or has a
|
||||
* wakeup pending to re-read the wounded state.
|
||||
*/
|
||||
if (owner != current)
|
||||
|
|
@ -946,7 +946,6 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
|
|||
}
|
||||
|
||||
debug_mutex_lock_common(lock, &waiter);
|
||||
debug_mutex_add_waiter(lock, &waiter, current);
|
||||
|
||||
lock_contended(&lock->dep_map, ip);
|
||||
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ static int __test_cycle(unsigned int nthreads)
|
|||
if (!cycle->result)
|
||||
continue;
|
||||
|
||||
pr_err("cylic deadlock not resolved, ret[%d/%d] = %d\n",
|
||||
pr_err("cyclic deadlock not resolved, ret[%d/%d] = %d\n",
|
||||
n, nthreads, cycle->result);
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ struct pid *alloc_pid(struct pid_namespace *ns)
|
|||
idr_preload_end();
|
||||
|
||||
if (nr < 0) {
|
||||
retval = nr;
|
||||
retval = (nr == -ENOSPC) ? -EAGAIN : nr;
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -351,7 +351,6 @@ static int console_msg_format = MSG_FORMAT_DEFAULT;
|
|||
*/
|
||||
|
||||
enum log_flags {
|
||||
LOG_NOCONS = 1, /* suppress print, do not print to console */
|
||||
LOG_NEWLINE = 2, /* text ended with a newline */
|
||||
LOG_PREFIX = 4, /* text started with a prefix */
|
||||
LOG_CONT = 8, /* text is a fragment of a continuation line */
|
||||
|
|
@ -1881,9 +1880,6 @@ int vprintk_store(int facility, int level,
|
|||
if (dict)
|
||||
lflags |= LOG_PREFIX|LOG_NEWLINE;
|
||||
|
||||
if (suppress_message_printing(level))
|
||||
lflags |= LOG_NOCONS;
|
||||
|
||||
return log_output(facility, level, lflags,
|
||||
dict, dictlen, text, text_len);
|
||||
}
|
||||
|
|
@ -2032,6 +2028,7 @@ static void call_console_drivers(const char *ext_text, size_t ext_len,
|
|||
const char *text, size_t len) {}
|
||||
static size_t msg_print_text(const struct printk_log *msg,
|
||||
bool syslog, char *buf, size_t size) { return 0; }
|
||||
static bool suppress_message_printing(int level) { return false; }
|
||||
|
||||
#endif /* CONFIG_PRINTK */
|
||||
|
||||
|
|
@ -2368,10 +2365,11 @@ skip:
|
|||
break;
|
||||
|
||||
msg = log_from_idx(console_idx);
|
||||
if (msg->flags & LOG_NOCONS) {
|
||||
if (suppress_message_printing(msg->level)) {
|
||||
/*
|
||||
* Skip record if !ignore_loglevel, and
|
||||
* record has level above the console loglevel.
|
||||
* Skip record we have buffered and already printed
|
||||
* directly to the console when we received it, and
|
||||
* record that has level above the console loglevel.
|
||||
*/
|
||||
console_idx = log_next(console_idx);
|
||||
console_seq++;
|
||||
|
|
|
|||
|
|
@ -89,12 +89,12 @@ struct static_key sched_feat_keys[__SCHED_FEAT_NR] = {
|
|||
|
||||
static void sched_feat_disable(int i)
|
||||
{
|
||||
static_key_disable(&sched_feat_keys[i]);
|
||||
static_key_disable_cpuslocked(&sched_feat_keys[i]);
|
||||
}
|
||||
|
||||
static void sched_feat_enable(int i)
|
||||
{
|
||||
static_key_enable(&sched_feat_keys[i]);
|
||||
static_key_enable_cpuslocked(&sched_feat_keys[i]);
|
||||
}
|
||||
#else
|
||||
static void sched_feat_disable(int i) { };
|
||||
|
|
@ -146,9 +146,11 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
|
|||
|
||||
/* Ensure the static_key remains in a consistent state */
|
||||
inode = file_inode(filp);
|
||||
cpus_read_lock();
|
||||
inode_lock(inode);
|
||||
ret = sched_feat_set(cmp);
|
||||
inode_unlock(inode);
|
||||
cpus_read_unlock();
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
|
|
|
|||
|
|
@ -3362,6 +3362,7 @@ update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)
|
|||
* attach_entity_load_avg - attach this entity to its cfs_rq load avg
|
||||
* @cfs_rq: cfs_rq to attach to
|
||||
* @se: sched_entity to attach
|
||||
* @flags: migration hints
|
||||
*
|
||||
* Must call update_cfs_rq_load_avg() before this, since we rely on
|
||||
* cfs_rq->avg.last_update_time being current.
|
||||
|
|
@ -7263,6 +7264,7 @@ static void update_blocked_averages(int cpu)
|
|||
{
|
||||
struct rq *rq = cpu_rq(cpu);
|
||||
struct cfs_rq *cfs_rq, *pos;
|
||||
const struct sched_class *curr_class;
|
||||
struct rq_flags rf;
|
||||
bool done = true;
|
||||
|
||||
|
|
@ -7299,8 +7301,10 @@ static void update_blocked_averages(int cpu)
|
|||
if (cfs_rq_has_blocked(cfs_rq))
|
||||
done = false;
|
||||
}
|
||||
update_rt_rq_load_avg(rq_clock_task(rq), rq, 0);
|
||||
update_dl_rq_load_avg(rq_clock_task(rq), rq, 0);
|
||||
|
||||
curr_class = rq->curr->sched_class;
|
||||
update_rt_rq_load_avg(rq_clock_task(rq), rq, curr_class == &rt_sched_class);
|
||||
update_dl_rq_load_avg(rq_clock_task(rq), rq, curr_class == &dl_sched_class);
|
||||
update_irq_load_avg(rq, 0);
|
||||
/* Don't need periodic decay once load/util_avg are null */
|
||||
if (others_have_blocked(rq))
|
||||
|
|
@ -7365,13 +7369,16 @@ static inline void update_blocked_averages(int cpu)
|
|||
{
|
||||
struct rq *rq = cpu_rq(cpu);
|
||||
struct cfs_rq *cfs_rq = &rq->cfs;
|
||||
const struct sched_class *curr_class;
|
||||
struct rq_flags rf;
|
||||
|
||||
rq_lock_irqsave(rq, &rf);
|
||||
update_rq_clock(rq);
|
||||
update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq);
|
||||
update_rt_rq_load_avg(rq_clock_task(rq), rq, 0);
|
||||
update_dl_rq_load_avg(rq_clock_task(rq), rq, 0);
|
||||
|
||||
curr_class = rq->curr->sched_class;
|
||||
update_rt_rq_load_avg(rq_clock_task(rq), rq, curr_class == &rt_sched_class);
|
||||
update_dl_rq_load_avg(rq_clock_task(rq), rq, curr_class == &dl_sched_class);
|
||||
update_irq_load_avg(rq, 0);
|
||||
#ifdef CONFIG_NO_HZ_COMMON
|
||||
rq->last_blocked_load_update_tick = jiffies;
|
||||
|
|
@ -7482,10 +7489,10 @@ static inline int get_sd_load_idx(struct sched_domain *sd,
|
|||
return load_idx;
|
||||
}
|
||||
|
||||
static unsigned long scale_rt_capacity(int cpu)
|
||||
static unsigned long scale_rt_capacity(struct sched_domain *sd, int cpu)
|
||||
{
|
||||
struct rq *rq = cpu_rq(cpu);
|
||||
unsigned long max = arch_scale_cpu_capacity(NULL, cpu);
|
||||
unsigned long max = arch_scale_cpu_capacity(sd, cpu);
|
||||
unsigned long used, free;
|
||||
unsigned long irq;
|
||||
|
||||
|
|
@ -7507,7 +7514,7 @@ static unsigned long scale_rt_capacity(int cpu)
|
|||
|
||||
static void update_cpu_capacity(struct sched_domain *sd, int cpu)
|
||||
{
|
||||
unsigned long capacity = scale_rt_capacity(cpu);
|
||||
unsigned long capacity = scale_rt_capacity(sd, cpu);
|
||||
struct sched_group *sdg = sd->groups;
|
||||
|
||||
cpu_rq(cpu)->cpu_capacity_orig = arch_scale_cpu_capacity(sd, cpu);
|
||||
|
|
@ -8269,7 +8276,7 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
|
|||
force_balance:
|
||||
/* Looks like there is an imbalance. Compute it */
|
||||
calculate_imbalance(env, &sds);
|
||||
return sds.busiest;
|
||||
return env->imbalance ? sds.busiest : NULL;
|
||||
|
||||
out_balanced:
|
||||
env->imbalance = 0;
|
||||
|
|
@ -9638,7 +9645,8 @@ static inline bool vruntime_normalized(struct task_struct *p)
|
|||
* - A task which has been woken up by try_to_wake_up() and
|
||||
* waiting for actually being woken up by sched_ttwu_pending().
|
||||
*/
|
||||
if (!se->sum_exec_runtime || p->state == TASK_WAKING)
|
||||
if (!se->sum_exec_runtime ||
|
||||
(p->state == TASK_WAKING && p->sched_remote_wakeup))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -1295,7 +1295,7 @@ static void init_numa_topology_type(void)
|
|||
|
||||
n = sched_max_numa_distance;
|
||||
|
||||
if (sched_domains_numa_levels <= 1) {
|
||||
if (sched_domains_numa_levels <= 2) {
|
||||
sched_numa_topology_type = NUMA_DIRECT;
|
||||
return;
|
||||
}
|
||||
|
|
@ -1380,9 +1380,6 @@ void sched_init_numa(void)
|
|||
break;
|
||||
}
|
||||
|
||||
if (!level)
|
||||
return;
|
||||
|
||||
/*
|
||||
* 'level' contains the number of unique distances
|
||||
*
|
||||
|
|
|
|||
|
|
@ -71,9 +71,6 @@
|
|||
#include <asm/io.h>
|
||||
#include <asm/unistd.h>
|
||||
|
||||
/* Hardening for Spectre-v1 */
|
||||
#include <linux/nospec.h>
|
||||
|
||||
#include "uid16.h"
|
||||
|
||||
#ifndef SET_UNALIGN_CTL
|
||||
|
|
|
|||
|
|
@ -133,19 +133,40 @@ static void inline clocksource_watchdog_unlock(unsigned long *flags)
|
|||
spin_unlock_irqrestore(&watchdog_lock, *flags);
|
||||
}
|
||||
|
||||
static int clocksource_watchdog_kthread(void *data);
|
||||
static void __clocksource_change_rating(struct clocksource *cs, int rating);
|
||||
|
||||
/*
|
||||
* Interval: 0.5sec Threshold: 0.0625s
|
||||
*/
|
||||
#define WATCHDOG_INTERVAL (HZ >> 1)
|
||||
#define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
|
||||
|
||||
static void clocksource_watchdog_work(struct work_struct *work)
|
||||
{
|
||||
/*
|
||||
* We cannot directly run clocksource_watchdog_kthread() here, because
|
||||
* clocksource_select() calls timekeeping_notify() which uses
|
||||
* stop_machine(). One cannot use stop_machine() from a workqueue() due
|
||||
* lock inversions wrt CPU hotplug.
|
||||
*
|
||||
* Also, we only ever run this work once or twice during the lifetime
|
||||
* of the kernel, so there is no point in creating a more permanent
|
||||
* kthread for this.
|
||||
*
|
||||
* If kthread_run fails the next watchdog scan over the
|
||||
* watchdog_list will find the unstable clock again.
|
||||
*/
|
||||
kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");
|
||||
}
|
||||
|
||||
static void __clocksource_unstable(struct clocksource *cs)
|
||||
{
|
||||
cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
|
||||
cs->flags |= CLOCK_SOURCE_UNSTABLE;
|
||||
|
||||
/*
|
||||
* If the clocksource is registered clocksource_watchdog_work() will
|
||||
* If the clocksource is registered clocksource_watchdog_kthread() will
|
||||
* re-rate and re-select.
|
||||
*/
|
||||
if (list_empty(&cs->list)) {
|
||||
|
|
@ -156,7 +177,7 @@ static void __clocksource_unstable(struct clocksource *cs)
|
|||
if (cs->mark_unstable)
|
||||
cs->mark_unstable(cs);
|
||||
|
||||
/* kick clocksource_watchdog_work() */
|
||||
/* kick clocksource_watchdog_kthread() */
|
||||
if (finished_booting)
|
||||
schedule_work(&watchdog_work);
|
||||
}
|
||||
|
|
@ -166,7 +187,7 @@ static void __clocksource_unstable(struct clocksource *cs)
|
|||
* @cs: clocksource to be marked unstable
|
||||
*
|
||||
* This function is called by the x86 TSC code to mark clocksources as unstable;
|
||||
* it defers demotion and re-selection to a work.
|
||||
* it defers demotion and re-selection to a kthread.
|
||||
*/
|
||||
void clocksource_mark_unstable(struct clocksource *cs)
|
||||
{
|
||||
|
|
@ -391,9 +412,7 @@ static void clocksource_dequeue_watchdog(struct clocksource *cs)
|
|||
}
|
||||
}
|
||||
|
||||
static void __clocksource_change_rating(struct clocksource *cs, int rating);
|
||||
|
||||
static int __clocksource_watchdog_work(void)
|
||||
static int __clocksource_watchdog_kthread(void)
|
||||
{
|
||||
struct clocksource *cs, *tmp;
|
||||
unsigned long flags;
|
||||
|
|
@ -418,12 +437,13 @@ static int __clocksource_watchdog_work(void)
|
|||
return select;
|
||||
}
|
||||
|
||||
static void clocksource_watchdog_work(struct work_struct *work)
|
||||
static int clocksource_watchdog_kthread(void *data)
|
||||
{
|
||||
mutex_lock(&clocksource_mutex);
|
||||
if (__clocksource_watchdog_work())
|
||||
if (__clocksource_watchdog_kthread())
|
||||
clocksource_select();
|
||||
mutex_unlock(&clocksource_mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool clocksource_is_watchdog(struct clocksource *cs)
|
||||
|
|
@ -442,7 +462,7 @@ static void clocksource_enqueue_watchdog(struct clocksource *cs)
|
|||
static void clocksource_select_watchdog(bool fallback) { }
|
||||
static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }
|
||||
static inline void clocksource_resume_watchdog(void) { }
|
||||
static inline int __clocksource_watchdog_work(void) { return 0; }
|
||||
static inline int __clocksource_watchdog_kthread(void) { return 0; }
|
||||
static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }
|
||||
void clocksource_mark_unstable(struct clocksource *cs) { }
|
||||
|
||||
|
|
@ -810,7 +830,7 @@ static int __init clocksource_done_booting(void)
|
|||
/*
|
||||
* Run the watchdog first to eliminate unstable clock sources
|
||||
*/
|
||||
__clocksource_watchdog_work();
|
||||
__clocksource_watchdog_kthread();
|
||||
clocksource_select();
|
||||
mutex_unlock(&clocksource_mutex);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -1546,6 +1546,8 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages)
|
|||
tmp_iter_page = first_page;
|
||||
|
||||
do {
|
||||
cond_resched();
|
||||
|
||||
to_remove_page = tmp_iter_page;
|
||||
rb_inc_page(cpu_buffer, &tmp_iter_page);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue