Merge tag 'sched-core-2022-10-07' of git:https://git.kernel.org/pub/scm/lin…

…ux/kernel/git/tip/tip

Pull scheduler updates from Ingo Molnar:
 "Debuggability:

   - Change most occurances of BUG_ON() to WARN_ON_ONCE()

   - Reorganize & fix TASK_ state comparisons, turn it into a bitmap

   - Update/fix misc scheduler debugging facilities

  Load-balancing & regular scheduling:

   - Improve the behavior of the scheduler in presence of lot of
     SCHED_IDLE tasks - in particular they should not impact other
     scheduling classes.

   - Optimize task load tracking, cleanups & fixes

   - Clean up & simplify misc load-balancing code

  Freezer:

   - Rewrite the core freezer to behave better wrt thawing and be
     simpler in general, by replacing PF_FROZEN with TASK_FROZEN &
     fixing/adjusting all the fallout.

  Deadline scheduler:

   - Fix the DL capacity-aware code

   - Factor out dl_task_is_earliest_deadline() &
     replenish_dl_new_period()

   - Relax/optimize locking in task_non_contending()

  Cleanups:

   - Factor out the update_current_exec_runtime() helper

   - Various cleanups, simplifications"

* tag 'sched-core-2022-10-07' of git:https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (41 commits)
  sched: Fix more TASK_state comparisons
  sched: Fix TASK_state comparisons
  sched/fair: Move call to list_last_entry() in detach_tasks
  sched/fair: Cleanup loop_max and loop_break
  sched/fair: Make sure to try to detach at least one movable task
  sched: Show PF_flag holes
  freezer,sched: Rewrite core freezer logic
  sched: Widen TAKS_state literals
  sched/wait: Add wait_event_state()
  sched/completion: Add wait_for_completion_state()
  sched: Add TASK_ANY for wait_task_inactive()
  sched: Change wait_task_inactive()s match_state
  freezer,umh: Clean up freezer/initrd interaction
  freezer: Have {,un}lock_system_sleep() save/restore flags
  sched: Rename task_running() to task_on_cpu()
  sched/fair: Cleanup for SIS_PROP
  sched/fair: Default to false in test_idle_cores()
  sched/fair: Remove useless check in select_idle_core()
  sched/fair: Avoid double search on same cpu
  sched/fair: Remove redundant check in select_idle_smt()
  ...

drivers/acpi/x86/s2idle.c

@@ -654,25 +654,29 @@ void __init acpi_s2idle_setup(void)
 
 int acpi_register_lps0_dev(struct acpi_s2idle_dev_ops *arg)
 {
+ unsigned int sleep_flags;
+
  if (!lps0_device_handle || sleep_no_lps0)
  return -ENODEV;
 
- lock_system_sleep();
+ sleep_flags = lock_system_sleep();
  list_add(&arg->list_node, &lps0_s2idle_devops_head);
- unlock_system_sleep();
+ unlock_system_sleep(sleep_flags);
 
  return 0;
 }
 EXPORT_SYMBOL_GPL(acpi_register_lps0_dev);
 
 void acpi_unregister_lps0_dev(struct acpi_s2idle_dev_ops *arg)
 {
+ unsigned int sleep_flags;
+
  if (!lps0_device_handle || sleep_no_lps0)
  return;
 
- lock_system_sleep();
+ sleep_flags = lock_system_sleep();
  list_del(&arg->list_node);
- unlock_system_sleep();
+ unlock_system_sleep(sleep_flags);
 }
 EXPORT_SYMBOL_GPL(acpi_unregister_lps0_dev);
 

drivers/android/binder.c

@@ -4259,10 +4259,9 @@ static int binder_wait_for_work(struct binder_thread *thread,
  struct binder_proc *proc = thread->proc;
  int ret = 0;
 
- freezer_do_not_count();
  binder_inner_proc_lock(proc);
  for (;;) {
- prepare_to_wait(&thread->wait, &wait, TASK_INTERRUPTIBLE);
+ prepare_to_wait(&thread->wait, &wait, TASK_INTERRUPTIBLE|TASK_FREEZABLE);
  if (binder_has_work_ilocked(thread, do_proc_work))
  break;
  if (do_proc_work)
@@ -4279,7 +4278,6 @@ static int binder_wait_for_work(struct binder_thread *thread,
  }
  finish_wait(&thread->wait, &wait);
  binder_inner_proc_unlock(proc);
- freezer_count();
 
  return ret;
 }

drivers/media/pci/pt3/pt3.c

@@ -445,8 +445,8 @@ static int pt3_fetch_thread(void *data)
  pt3_proc_dma(adap);
 
  delay = ktime_set(0, PT3_FETCH_DELAY * NSEC_PER_MSEC);
- set_current_state(TASK_UNINTERRUPTIBLE);
- freezable_schedule_hrtimeout_range(&delay,
+ set_current_state(TASK_UNINTERRUPTIBLE|TASK_FREEZABLE);
+ schedule_hrtimeout_range(&delay,
  PT3_FETCH_DELAY_DELTA * NSEC_PER_MSEC,
  HRTIMER_MODE_REL);
  }

drivers/powercap/idle_inject.c

@@ -254,7 +254,7 @@ void idle_inject_stop(struct idle_inject_device *ii_dev)
  iit = per_cpu_ptr(&idle_inject_thread, cpu);
  iit->should_run = 0;
 
- wait_task_inactive(iit->tsk, 0);
+ wait_task_inactive(iit->tsk, TASK_ANY);
  }
 
  cpu_hotplug_enable();

drivers/scsi/scsi_transport_spi.c

@@ -998,16 +998,17 @@ void
 spi_dv_device(struct scsi_device *sdev)
 {
  struct scsi_target *starget = sdev->sdev_target;
- u8 *buffer;
  const int len = SPI_MAX_ECHO_BUFFER_SIZE*2;
+ unsigned int sleep_flags;
+ u8 *buffer;
 
  /*
  * Because this function and the power management code both call
  * scsi_device_quiesce(), it is not safe to perform domain validation
  * while suspend or resume is in progress. Hence the
  * lock/unlock_system_sleep() calls.
  */
- lock_system_sleep();
+ sleep_flags = lock_system_sleep();
 
  if (scsi_autopm_get_device(sdev))
  goto unlock_system_sleep;
@@ -1058,7 +1059,7 @@ spi_dv_device(struct scsi_device *sdev)
  scsi_autopm_put_device(sdev);
 
 unlock_system_sleep:
- unlock_system_sleep();
+ unlock_system_sleep(sleep_flags);
 }
 EXPORT_SYMBOL(spi_dv_device);
 

fs/cifs/inode.c

@@ -2327,7 +2327,7 @@ cifs_invalidate_mapping(struct inode *inode)
 static int
 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
 {
- freezable_schedule_unsafe();
+ schedule();
  if (signal_pending_state(mode, current))
  return -ERESTARTSYS;
  return 0;
@@ -2345,7 +2345,7 @@ cifs_revalidate_mapping(struct inode *inode)
  return 0;
 
  rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
- TASK_KILLABLE);
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
  if (rc)
  return rc;
 

fs/cifs/transport.c

@@ -753,8 +753,9 @@ wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 {
  int error;
 
- error = wait_event_freezekillable_unsafe(server->response_q,
- midQ->mid_state != MID_REQUEST_SUBMITTED);
+ error = wait_event_state(server->response_q,
+ midQ->mid_state != MID_REQUEST_SUBMITTED,
+ (TASK_KILLABLE|TASK_FREEZABLE_UNSAFE));
  if (error < 0)
  return -ERESTARTSYS;
 

fs/coredump.c

@@ -402,17 +402,16 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
  if (core_waiters > 0) {
  struct core_thread *ptr;
 
- freezer_do_not_count();
- wait_for_completion(&core_state->startup);
- freezer_count();
+ wait_for_completion_state(&core_state->startup,
+ TASK_UNINTERRUPTIBLE|TASK_FREEZABLE);
  /*
  * Wait for all the threads to become inactive, so that
  * all the thread context (extended register state, like
  * fpu etc) gets copied to the memory.
  */
  ptr = core_state->dumper.next;
  while (ptr != NULL) {
- wait_task_inactive(ptr->task, 0);
+ wait_task_inactive(ptr->task, TASK_ANY);
  ptr = ptr->next;
  }
  }

fs/nfs/file.c

@@ -567,7 +567,8 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf)
  }
 
  wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING,
- nfs_wait_bit_killable, TASK_KILLABLE);
+ nfs_wait_bit_killable,
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
 
  lock_page(page);
  mapping = page_file_mapping(page);

fs/nfs/inode.c

@@ -72,18 +72,13 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
  return nfs_fileid_to_ino_t(fattr->fileid);
 }
 
-static int nfs_wait_killable(int mode)
+int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
 {
- freezable_schedule_unsafe();
+ schedule();
  if (signal_pending_state(mode, current))
  return -ERESTARTSYS;
  return 0;
 }
-
-int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
-{
- return nfs_wait_killable(mode);
-}
 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
 
 /**
@@ -1332,7 +1327,8 @@ int nfs_clear_invalid_mapping(struct address_space *mapping)
  */
  for (;;) {
  ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
- nfs_wait_bit_killable, TASK_KILLABLE);
+ nfs_wait_bit_killable,
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
  if (ret)
  goto out;
  spin_lock(&inode->i_lock);

fs/nfs/nfs3proc.c

@@ -36,7 +36,8 @@ nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
  res = rpc_call_sync(clnt, msg, flags);
  if (res != -EJUKEBOX)
  break;
- freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
+ __set_current_state(TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
+ schedule_timeout(NFS_JUKEBOX_RETRY_TIME);
  res = -ERESTARTSYS;
  } while (!fatal_signal_pending(current));
  return res;

fs/nfs/nfs4proc.c

@@ -416,8 +416,8 @@ static int nfs4_delay_killable(long *timeout)
 {
  might_sleep();
 
- freezable_schedule_timeout_killable_unsafe(
-  nfs4_update_delay(timeout));
+ __set_current_state(TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
+ schedule_timeout(nfs4_update_delay(timeout));
  if (!__fatal_signal_pending(current))
  return 0;
  return -EINTR;
@@ -427,7 +427,8 @@ static int nfs4_delay_interruptible(long *timeout)
 {
  might_sleep();
 
- freezable_schedule_timeout_interruptible_unsafe(nfs4_update_delay(timeout));
+ __set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE_UNSAFE);
+ schedule_timeout(nfs4_update_delay(timeout));
  if (!signal_pending(current))
  return 0;
  return __fatal_signal_pending(current) ? -EINTR :-ERESTARTSYS;
@@ -7406,7 +7407,8 @@ nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
  status = nfs4_proc_setlk(state, cmd, request);
  if ((status != -EAGAIN) || IS_SETLK(cmd))
  break;
- freezable_schedule_timeout_interruptible(timeout);
+ __set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
+ schedule_timeout(timeout);
  timeout *= 2;
  timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
  status = -ERESTARTSYS;
@@ -7474,10 +7476,8 @@ nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
  break;
 
  status = -ERESTARTSYS;
- freezer_do_not_count();
- wait_woken(&waiter.wait, TASK_INTERRUPTIBLE,
+ wait_woken(&waiter.wait, TASK_INTERRUPTIBLE|TASK_FREEZABLE,
  NFS4_LOCK_MAXTIMEOUT);
- freezer_count();
  } while (!signalled());
 
  remove_wait_queue(q, &waiter.wait);

fs/nfs/nfs4state.c

@@ -1314,7 +1314,8 @@ int nfs4_wait_clnt_recover(struct nfs_client *clp)
 
  refcount_inc(&clp->cl_count);
  res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
- nfs_wait_bit_killable, TASK_KILLABLE);
+ nfs_wait_bit_killable,
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
  if (res)
  goto out;
  if (clp->cl_cons_state < 0)

fs/nfs/pnfs.c

@@ -1908,7 +1908,7 @@ static int pnfs_prepare_to_retry_layoutget(struct pnfs_layout_hdr *lo)
  pnfs_layoutcommit_inode(lo->plh_inode, false);
  return wait_on_bit_action(&lo->plh_flags, NFS_LAYOUT_RETURN,
  nfs_wait_bit_killable,
- TASK_KILLABLE);
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
 }
 
 static void nfs_layoutget_begin(struct pnfs_layout_hdr *lo)
@@ -3192,7 +3192,7 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
  status = wait_on_bit_lock_action(&nfsi->flags,
  NFS_INO_LAYOUTCOMMITTING,
  nfs_wait_bit_killable,
- TASK_KILLABLE);
+ TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
  if (status)
  goto out;
  }

fs/xfs/xfs_trans_ail.c

@@ -602,9 +602,9 @@ xfsaild(
 
  while (1) {
  if (tout && tout <= 20)
- set_current_state(TASK_KILLABLE);
+ set_current_state(TASK_KILLABLE|TASK_FREEZABLE);
  else
- set_current_state(TASK_INTERRUPTIBLE);
+ set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
 
  /*
  * Check kthread_should_stop() after we set the task state to
@@ -653,14 +653,14 @@ xfsaild(
  ailp->ail_target == ailp->ail_target_prev &&
  list_empty(&ailp->ail_buf_list)) {
  spin_unlock(&ailp->ail_lock);
- freezable_schedule();
+ schedule();
  tout = 0;
  continue;
  }
  spin_unlock(&ailp->ail_lock);
 
  if (tout)
- freezable_schedule_timeout(msecs_to_jiffies(tout));
+ schedule_timeout(msecs_to_jiffies(tout));
 
  __set_current_state(TASK_RUNNING);
 

include/linux/completion.h

@@ -103,6 +103,7 @@ extern void wait_for_completion(struct completion *);
 extern void wait_for_completion_io(struct completion *);
 extern int wait_for_completion_interruptible(struct completion *x);
 extern int wait_for_completion_killable(struct completion *x);
+extern int wait_for_completion_state(struct completion *x, unsigned int state);
 extern unsigned long wait_for_completion_timeout(struct completion *x,
  unsigned long timeout);
 extern unsigned long wait_for_completion_io_timeout(struct completion *x,