Merge tag 'pm-fixes-for-3.3-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

torvalds · torvalds · commit 23783f817bce · 2012-02-04T15:21:39.000-08:00
Power management fixes for 3.3-rc3

Three power management regression fixes, one for a recent regression introcuded
by the freezer changes during the 3.3 merge window and two for regressions
in cpuidle (resulting from PM QoS changes) and in the hibernate user space
interface, both introduced during the 3.2 development cycle.

They include:

* Two hibernate (s2disk) regression fixes from Srivatsa S. Bhat (for
 regressions introduced during the 3.3 merge window and during the 3.2
 development cycle).

* A cpuidle fix from Venki Pallipadi for a regression resulting from PM QoS
 changes during the 3.2 development cycle causing cpuidle to work incorrectly
 for CONFIG_PM unset.

* tag 'pm-fixes-for-3.3-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  PM / QoS: CPU C-state breakage with PM Qos change
  PM / Freezer: Thaw only kernel threads if freezing of kernel threads fails
  PM / Hibernate: Thaw kernel threads in SNAPSHOT_CREATE_IMAGE ioctl path
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
@@ -110,7 +110,19 @@ static inline void pm_qos_remove_request(struct pm_qos_request *req)
 			{ return; }
 
 static inline int pm_qos_request(int pm_qos_class)
-			{ return 0; }
+{
+	switch (pm_qos_class) {
+	case PM_QOS_CPU_DMA_LATENCY:
+		return PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
+	case PM_QOS_NETWORK_LATENCY:
+		return PM_QOS_NETWORK_LAT_DEFAULT_VALUE;
+	case PM_QOS_NETWORK_THROUGHPUT:
+		return PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE;
+	default:
+		return PM_QOS_DEFAULT_VALUE;
+	}
+}
+
 static inline int pm_qos_add_notifier(int pm_qos_class,
 				      struct notifier_block *notifier)
 			{ return 0; }
diff --git a/kernel/power/power.h b/kernel/power/power.h
@@ -231,8 +231,28 @@ extern int pm_test_level;
 #ifdef CONFIG_SUSPEND_FREEZER
 static inline int suspend_freeze_processes(void)
 {
-	int error = freeze_processes();
-	return error ? : freeze_kernel_threads();
+	int error;
+
+	error = freeze_processes();
+
+	/*
+	 * freeze_processes() automatically thaws every task if freezing
+	 * fails. So we need not do anything extra upon error.
+	 */
+	if (error)
+		goto Finish;
+
+	error = freeze_kernel_threads();
+
+	/*
+	 * freeze_kernel_threads() thaws only kernel threads upon freezing
+	 * failure. So we have to thaw the userspace tasks ourselves.
+	 */
+	if (error)
+		thaw_processes();
+
+ Finish:
+	return error;
 }
 
 static inline void suspend_thaw_processes(void)
diff --git a/kernel/power/process.c b/kernel/power/process.c
@@ -143,7 +143,10 @@ int freeze_processes(void)
 /**
  * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
  *
- * On success, returns 0.  On failure, -errno and system is fully thawed.
+ * On success, returns 0.  On failure, -errno and only the kernel threads are
+ * thawed, so as to give a chance to the caller to do additional cleanups
+ * (if any) before thawing the userspace tasks. So, it is the responsibility
+ * of the caller to thaw the userspace tasks, when the time is right.
  */
 int freeze_kernel_threads(void)
 {
@@ -159,7 +162,7 @@ int freeze_kernel_threads(void)
 	BUG_ON(in_atomic());
 
 	if (error)
-		thaw_processes();
+		thaw_kernel_threads();
 	return error;
 }
 
diff --git a/kernel/power/user.c b/kernel/power/user.c
@@ -249,13 +249,15 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
 		}
 		pm_restore_gfp_mask();
 		error = hibernation_snapshot(data->platform_support);
-		if (!error) {
+		if (error) {
+			thaw_kernel_threads();
+		} else {
 			error = put_user(in_suspend, (int __user *)arg);
 			if (!error && !freezer_test_done)
 				data->ready = 1;
 			if (freezer_test_done) {
 				freezer_test_done = false;
-				thaw_processes();
+				thaw_kernel_threads();
 			}
 		}
 		break;

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,10 @@ int freeze_processes(void)`
`143`	`143`	`/**`
`144`	`144`	`* freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.`
`145`	`145`	`*`
`146`		`- * On success, returns 0. On failure, -errno and system is fully thawed.`
	`146`	`+ * On success, returns 0. On failure, -errno and only the kernel threads are`
	`147`	`+ * thawed, so as to give a chance to the caller to do additional cleanups`
	`148`	`+ * (if any) before thawing the userspace tasks. So, it is the responsibility`
	`149`	`+ * of the caller to thaw the userspace tasks, when the time is right.`
`147`	`150`	`*/`
`148`	`151`	`int freeze_kernel_threads(void)`
`149`	`152`	`{`
`@@ -159,7 +162,7 @@ int freeze_kernel_threads(void)`
`159`	`162`	`BUG_ON(in_atomic());`
`160`	`163`
`161`	`164`	`if (error)`
`162`		`- thaw_processes();`
	`165`	`+ thaw_kernel_threads();`
`163`	`166`	`return error;`
`164`	`167`	`}`
`165`	`168`
Original file line number	Diff line number	Diff line change
`@@ -249,13 +249,15 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,`
`249`	`249`	`}`
`250`	`250`	`pm_restore_gfp_mask();`
`251`	`251`	`error = hibernation_snapshot(data->platform_support);`
`252`		`- if (!error) {`
	`252`	`+ if (error) {`
	`253`	`+ thaw_kernel_threads();`
	`254`	`+ } else {`
`253`	`255`	`error = put_user(in_suspend, (int __user *)arg);`
`254`	`256`	`if (!error && !freezer_test_done)`
`255`	`257`	`data->ready = 1;`
`256`	`258`	`if (freezer_test_done) {`
`257`	`259`	`freezer_test_done = false;`
`258`		`- thaw_processes();`
	`260`	`+ thaw_kernel_threads();`
`259`	`261`	`}`
`260`	`262`	`}`
`261`	`263`	`break;`