Revert "Merge: cgroup: Backport upstream cgroup commits up to v6.8"

This reverts merge request !4128

Author: zampierilucas

Documentation/admin-guide/cgroup-v2.rst

@@ -983,23 +983,6 @@ All cgroup core files are prefixed with "cgroup."
 	killing cgroups is a process directed operation, i.e. it affects
 	the whole thread-group.
 
-  cgroup.pressure
-	A read-write single value file that allowed values are "0" and "1".
-	The default is "1".
-
-	Writing "0" to the file will disable the cgroup PSI accounting.
-	Writing "1" to the file will re-enable the cgroup PSI accounting.
-
-	This control attribute is not hierarchical, so disable or enable PSI
-	accounting in a cgroup does not affect PSI accounting in descendants
-	and doesn't need pass enablement via ancestors from root.
-
-	The reason this control attribute exists is that PSI accounts stalls for
-	each cgroup separately and aggregates it at each level of the hierarchy.
-	This may cause non-negligible overhead for some workloads when under
-	deep level of the hierarchy, in which case this control attribute can
-	be used to disable PSI accounting in the non-leaf cgroups.
-
   irq.pressure
 	A read-write nested-keyed file.
 

Documentation/power/freezing-of-tasks.rst

@@ -14,28 +14,27 @@ architectures).
 II. How does it work?
 =====================
 
-There is one per-task flag (PF_NOFREEZE) and three per-task states
-(TASK_FROZEN, TASK_FREEZABLE and __TASK_FREEZABLE_UNSAFE) used for that.
-The tasks that have PF_NOFREEZE unset (all user space tasks and some kernel
-threads) are regarded as 'freezable' and treated in a special way before the
-system enters a sleep state as well as before a hibernation image is created
-(hibernation is directly covered by what follows, but the description applies
-to system-wide suspend too).
+There are three per-task flags used for that, PF_NOFREEZE, PF_FROZEN
+and PF_FREEZER_SKIP (the last one is auxiliary).  The tasks that have
+PF_NOFREEZE unset (all user space processes and some kernel threads) are
+regarded as 'freezable' and treated in a special way before the system enters a
+suspend state as well as before a hibernation image is created (in what follows
+we only consider hibernation, but the description also applies to suspend).
 
 Namely, as the first step of the hibernation procedure the function
 freeze_processes() (defined in kernel/power/process.c) is called.  A system-wide
-static key freezer_active (as opposed to a per-task flag or state) is used to
-indicate whether the system is to undergo a freezing operation. And
-freeze_processes() sets this static key.  After this, it executes
-try_to_freeze_tasks() that sends a fake signal to all user space processes, and
-wakes up all the kernel threads. All freezable tasks must react to that by
-calling try_to_freeze(), which results in a call to __refrigerator() (defined
-in kernel/freezer.c), which changes the task's state to TASK_FROZEN, and makes
-it loop until it is woken by an explicit TASK_FROZEN wakeup. Then, that task
-is regarded as 'frozen' and so the set of functions handling this mechanism is
-referred to as 'the freezer' (these functions are defined in
-kernel/power/process.c, kernel/freezer.c & include/linux/freezer.h). User space
-tasks are generally frozen before kernel threads.
+variable system_freezing_cnt (as opposed to a per-task flag) is used to indicate
+whether the system is to undergo a freezing operation. And freeze_processes()
+sets this variable.  After this, it executes try_to_freeze_tasks() that sends a
+fake signal to all user space processes, and wakes up all the kernel threads.
+All freezable tasks must react to that by calling try_to_freeze(), which
+results in a call to __refrigerator() (defined in kernel/freezer.c), which sets
+the task's PF_FROZEN flag, changes its state to TASK_UNINTERRUPTIBLE and makes
+it loop until PF_FROZEN is cleared for it. Then, we say that the task is
+'frozen' and therefore the set of functions handling this mechanism is referred
+to as 'the freezer' (these functions are defined in kernel/power/process.c,
+kernel/freezer.c & include/linux/freezer.h). User space processes are generally
+frozen before kernel threads.
 
 __refrigerator() must not be called directly.  Instead, use the
 try_to_freeze() function (defined in include/linux/freezer.h), that checks
@@ -44,40 +43,31 @@ if the task is to be frozen and makes the task enter __refrigerator().
 For user space processes try_to_freeze() is called automatically from the
 signal-handling code, but the freezable kernel threads need to call it
 explicitly in suitable places or use the wait_event_freezable() or
-wait_event_freezable_timeout() macros (defined in include/linux/wait.h)
-that put the task to sleep (TASK_INTERRUPTIBLE) or freeze it (TASK_FROZEN) if
-freezer_active is set. The main loop of a freezable kernel thread may look
+wait_event_freezable_timeout() macros (defined in include/linux/freezer.h)
+that combine interruptible sleep with checking if the task is to be frozen and
+calling try_to_freeze().  The main loop of a freezable kernel thread may look
 like the following one::
 
 	set_freezable();
-
-	while (true) {
-		struct task_struct *tsk = NULL;
-
-		wait_event_freezable(oom_reaper_wait, oom_reaper_list != NULL);
-		spin_lock_irq(&oom_reaper_lock);
-		if (oom_reaper_list != NULL) {
-			tsk = oom_reaper_list;
-			oom_reaper_list = tsk->oom_reaper_list;
-		}
-		spin_unlock_irq(&oom_reaper_lock);
-
-		if (tsk)
-			oom_reap_task(tsk);
-	}
-
-(from mm/oom_kill.c::oom_reaper()).
-
-If a freezable kernel thread is not put to the frozen state after the freezer
-has initiated a freezing operation, the freezing of tasks will fail and the
-entire system-wide transition will be cancelled.  For this reason, freezable
-kernel threads must call try_to_freeze() somewhere or use one of the
+	do {
+		hub_events();
+		wait_event_freezable(khubd_wait,
+				!list_empty(&hub_event_list) ||
+				kthread_should_stop());
+	} while (!kthread_should_stop() || !list_empty(&hub_event_list));
+
+(from drivers/usb/core/hub.c::hub_thread()).
+
+If a freezable kernel thread fails to call try_to_freeze() after the freezer has
+initiated a freezing operation, the freezing of tasks will fail and the entire
+hibernation operation will be cancelled.  For this reason, freezable kernel
+threads must call try_to_freeze() somewhere or use one of the
 wait_event_freezable() and wait_event_freezable_timeout() macros.
 
 After the system memory state has been restored from a hibernation image and
 devices have been reinitialized, the function thaw_processes() is called in
-order to wake up each frozen task.  Then, the tasks that have been frozen leave
-__refrigerator() and continue running.
+order to clear the PF_FROZEN flag for each frozen task.  Then, the tasks that
+have been frozen leave __refrigerator() and continue running.
 
 
 Rationale behind the functions dealing with freezing and thawing of tasks
@@ -106,8 +96,7 @@ III. Which kernel threads are freezable?
 Kernel threads are not freezable by default.  However, a kernel thread may clear
 PF_NOFREEZE for itself by calling set_freezable() (the resetting of PF_NOFREEZE
 directly is not allowed).  From this point it is regarded as freezable
-and must call try_to_freeze() or variants of wait_event_freezable() in a
-suitable place.
+and must call try_to_freeze() in a suitable place.
 
 IV. Why do we do that?
 ======================

drivers/android/binder.c

@@ -3714,9 +3714,10 @@ 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|TASK_FREEZABLE);
+		prepare_to_wait(&thread->wait, &wait, TASK_INTERRUPTIBLE);
 		if (binder_has_work_ilocked(thread, do_proc_work))
 			break;
 		if (do_proc_work)
@@ -3733,6 +3734,7 @@ 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|TASK_FREEZABLE);
-		schedule_hrtimeout_range(&delay,
+		set_current_state(TASK_UNINTERRUPTIBLE);
+		freezable_schedule_hrtimeout_range(&delay,
 					PT3_FETCH_DELAY_DELTA * NSEC_PER_MSEC,
 					HRTIMER_MODE_REL);
 	}

fs/coredump.c

@@ -403,8 +403,9 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
 	if (core_waiters > 0) {
 		struct core_thread *ptr;
 
-		wait_for_completion_state(&core_state->startup,
-					  TASK_UNINTERRUPTIBLE|TASK_FREEZABLE);
+		freezer_do_not_count();
+		wait_for_completion(&core_state->startup);
+		freezer_count();
 		/*
 		 * Wait for all the threads to become inactive, so that
 		 * all the thread context (extended register state, like

fs/nfs/file.c

@@ -578,8 +578,7 @@ 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|TASK_FREEZABLE_UNSAFE);
+			nfs_wait_bit_killable, TASK_KILLABLE);
 
 	folio_lock(folio);
 	mapping = folio_file_mapping(folio);

fs/nfs/inode.c

@@ -72,13 +72,18 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
 	return nfs_fileid_to_ino_t(fattr->fileid);
 }
 
-int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
+static int nfs_wait_killable(int mode)
 {
-	schedule();
+	freezable_schedule_unsafe();
 	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);
 
 /**
@@ -1338,8 +1343,7 @@ 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|TASK_FREEZABLE_UNSAFE);
+					 nfs_wait_bit_killable, TASK_KILLABLE);
 		if (ret)
 			goto out;
 		spin_lock(&inode->i_lock);

fs/nfs/nfs3proc.c

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

fs/nfs/nfs4proc.c

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

fs/nfs/nfs4state.c

@@ -1317,8 +1317,7 @@ 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|TASK_FREEZABLE_UNSAFE);
+				 nfs_wait_bit_killable, TASK_KILLABLE);
 	if (res)
 		goto out;
 	if (clp->cl_cons_state < 0)