Commit 5d3c0db4 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'sched-core-2021-08-30' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull scheduler updates from Ingo Molnar:

 - The biggest change in this cycle is scheduler support for asymmetric
   scheduling affinity, to support the execution of legacy 32-bit tasks
   on AArch32 systems that also have 64-bit-only CPUs.

   Architectures can fill in this functionality by defining their own
   task_cpu_possible_mask(p). When this is done, the scheduler will make
   sure the task will only be scheduled on CPUs that support it.

   (The actual arm64 specific changes are not part of this tree.)

   For other architectures there will be no change in functionality.

 - Add cgroup SCHED_IDLE support

 - Increase node-distance flexibility & delay determining it until a CPU
   is brought online. (This enables platforms where node distance isn't
   final until the CPU is only.)

 - Deadline scheduler enhancements & fixes

 - Misc fixes & cleanups.

* tag 'sched-core-2021-08-30' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (27 commits)
  eventfd: Make signal recursion protection a task bit
  sched/fair: Mark tg_is_idle() an inline in the !CONFIG_FAIR_GROUP_SCHED case
  sched: Introduce dl_task_check_affinity() to check proposed affinity
  sched: Allow task CPU affinity to be restricted on asymmetric systems
  sched: Split the guts of sched_setaffinity() into a helper function
  sched: Introduce task_struct::user_cpus_ptr to track requested affinity
  sched: Reject CPU affinity changes based on task_cpu_possible_mask()
  cpuset: Cleanup cpuset_cpus_allowed_fallback() use in select_fallback_rq()
  cpuset: Honour task_cpu_possible_mask() in guarantee_online_cpus()
  cpuset: Don't use the cpu_possible_mask as a last resort for cgroup v1
  sched: Introduce task_cpu_possible_mask() to limit fallback rq selection
  sched: Cgroup SCHED_IDLE support
  sched/topology: Skip updating masks for non-online nodes
  sched: Replace deprecated CPU-hotplug functions.
  sched: Skip priority checks with SCHED_FLAG_KEEP_PARAMS
  sched: Fix UCLAMP_FLAG_IDLE setting
  sched/deadline: Fix missing clock update in migrate_task_rq_dl()
  sched/fair: Avoid a second scan of target in select_idle_cpu
  sched/fair: Use prev instead of new target as recent_used_cpu
  sched: Don't report SCHED_FLAG_SUGOV in sched_getattr()
  ...
parents 230bda08 b542e383

fs/aio.c

+1 −1
Original line number Diff line number Diff line
@@ -1695,7 +1695,7 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, 
		list_del(&iocb->ki_list);

		iocb->ki_res.res = mangle_poll(mask);

		req->done = true;

		if (iocb->ki_eventfd && eventfd_signal_count()) {

		if (iocb->ki_eventfd && eventfd_signal_allowed()) {

			iocb = NULL;

			INIT_WORK(&req->work, aio_poll_put_work);

			schedule_work(&req->work);

fs/eventfd.c

+5 −7
Original line number Diff line number Diff line
@@ -25,8 +25,6 @@ 
#include <linux/idr.h>

#include <linux/uio.h>



DEFINE_PER_CPU(int, eventfd_wake_count);



static DEFINE_IDA(eventfd_ida);



struct eventfd_ctx {
@@ -67,21 +65,21 @@ __u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n) 
	 * Deadlock or stack overflow issues can happen if we recurse here

	 * through waitqueue wakeup handlers. If the caller users potentially

	 * nested waitqueues with custom wakeup handlers, then it should

	 * check eventfd_signal_count() before calling this function. If

	 * it returns true, the eventfd_signal() call should be deferred to a

	 * check eventfd_signal_allowed() before calling this function. If

	 * it returns false, the eventfd_signal() call should be deferred to a

	 * safe context.

	 */

	if (WARN_ON_ONCE(this_cpu_read(eventfd_wake_count)))

	if (WARN_ON_ONCE(current->in_eventfd_signal))

		return 0;



	spin_lock_irqsave(&ctx->wqh.lock, flags);

	this_cpu_inc(eventfd_wake_count);

	current->in_eventfd_signal = 1;

	if (ULLONG_MAX - ctx->count < n)

		n = ULLONG_MAX - ctx->count;

	ctx->count += n;

	if (waitqueue_active(&ctx->wqh))

		wake_up_locked_poll(&ctx->wqh, EPOLLIN);

	this_cpu_dec(eventfd_wake_count);

	current->in_eventfd_signal = 0;

	spin_unlock_irqrestore(&ctx->wqh.lock, flags);



	return n;

include/linux/cpuset.h

+5 −3
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include <linux/cpumask.h>

#include <linux/nodemask.h>

#include <linux/mm.h>

#include <linux/mmu_context.h>

#include <linux/jump_label.h>



#ifdef CONFIG_CPUSETS
@@ -58,7 +59,7 @@ extern void cpuset_wait_for_hotplug(void); 
extern void cpuset_read_lock(void);

extern void cpuset_read_unlock(void);

extern void cpuset_cpus_allowed(struct task_struct *p, struct cpumask *mask);

extern void cpuset_cpus_allowed_fallback(struct task_struct *p);

extern bool cpuset_cpus_allowed_fallback(struct task_struct *p);

extern nodemask_t cpuset_mems_allowed(struct task_struct *p);

#define cpuset_current_mems_allowed (current->mems_allowed)

void cpuset_init_current_mems_allowed(void);
@@ -184,11 +185,12 @@ static inline void cpuset_read_unlock(void) { } 
static inline void cpuset_cpus_allowed(struct task_struct *p,

				       struct cpumask *mask)

{

	cpumask_copy(mask, cpu_possible_mask);

	cpumask_copy(mask, task_cpu_possible_mask(p));

}



static inline void cpuset_cpus_allowed_fallback(struct task_struct *p)

static inline bool cpuset_cpus_allowed_fallback(struct task_struct *p)

{

	return false;

}



static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)

include/linux/eventfd.h

+5 −6
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include <linux/err.h>

#include <linux/percpu-defs.h>

#include <linux/percpu.h>

#include <linux/sched.h>



/*

 * CAREFUL: Check include/uapi/asm-generic/fcntl.h when defining
@@ -43,11 +44,9 @@ int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *w 
				  __u64 *cnt);

void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt);



DECLARE_PER_CPU(int, eventfd_wake_count);



static inline bool eventfd_signal_count(void)

static inline bool eventfd_signal_allowed(void)

{

	return this_cpu_read(eventfd_wake_count);

	return !current->in_eventfd_signal;

}



#else /* CONFIG_EVENTFD */
@@ -78,9 +77,9 @@ static inline int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, 
	return -ENOSYS;

}



static inline bool eventfd_signal_count(void)

static inline bool eventfd_signal_allowed(void)

{

	return false;

	return true;

}



static inline void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt)

include/linux/mmu_context.h

+14 −0
Original line number Diff line number Diff line
@@ -14,4 +14,18 @@ 
static inline void leave_mm(int cpu) { }

#endif



/*

 * CPUs that are capable of running user task @p. Must contain at least one

 * active CPU. It is assumed that the kernel can run on all CPUs, so calling

 * this for a kernel thread is pointless.

 *

 * By default, we assume a sane, homogeneous system.

 */

#ifndef task_cpu_possible_mask

# define task_cpu_possible_mask(p)	cpu_possible_mask

# define task_cpu_possible(cpu, p)	true

#else

# define task_cpu_possible(cpu, p)	cpumask_test_cpu((cpu), task_cpu_possible_mask(p))

#endif



#endif