Skip to contentSkip to conversation

Suspend block api (version 3)

RFC PATCH In review Arve Hjønnevåg 6 participants 42 messages May 5, 2009 – May 15, 2009

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover Suspend block api (version 3)

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

---
Arve Hjønnevåg

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#1 lore raw

PATCH 1/9 PM: Add suspend block api.

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

---
 Documentation/power/suspend-blockers.txt |   94 +++++++++++++
 include/linux/suspend_blocker.h          |   60 +++++++++
 kernel/power/Kconfig                     |   10 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/main.c                      |   62 +++++++++-
 kernel/power/power.h                     |    4 +
 kernel/power/suspend_blocker.c           |  209 ++++++++++++++++++++++++++++++
 7 files changed, 439 insertions(+), 1 deletions(-)
 create mode 100644 Documentation/power/suspend-blockers.txt
 create mode 100755 include/linux/suspend_blocker.h
 create mode 100644 kernel/power/suspend_blocker.c
Documentation/power/suspend-blockers.txt new file +94 -0
new file mode 100644
index 0000000..5a33ed6
@@ -0,0 +1,94 @@
+Suspend blockers
+================
+
+Suspend blockers provide a mechanism for device drivers and user-space processes
+to prevent the system from entering suspend. Only suspend states requested
+through /sys/power/request_state are prevented. Writing to /sys/power/state
+will ignore suspend blockers, and sleep states entered from idle are unaffected.
+
+To use a suspend blocker, a device driver needs a struct suspend_blocker object
+that has to be initialized with suspend_blocker_init. When no longer needed,
+the suspend blocker must be destroyed with suspend_blocker_destroy.
+
+A suspend blocker is activated using suspend_block, which prevents the system
+from entering suspend until the suspend blocker is deactivated with
+suspend_unblock. Many suspend blockers may be used simultaneously, and the
+system is prevented from entering suspend as long as at least one of them is
+active.
+
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached called suspend_ops->enter. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but some or all drivers
+may be temporarily suspended.
+
+In cell phones or other embedded systems where powering the screen is a
+significant drain on the battery, suspend blockers can be used to allow
+user-space to decide whether a keystroke received while the system is suspended
+should cause the screen to be turned back on or allow the system to go back into
+suspend. Use set_irq_wake or a platform specific api to make sure the keypad
+interrupt wakes up the cpu. Once the keypad driver has resumed, the sequence of
+events can look like this:
+
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. If it determines that
+  the key should leave the screen off, it calls suspend_unblock on the
+  process_input_events suspend_blocker and then calls select or poll. The
+  system will automatically suspend again, since now no suspend blockers are
+  active.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+	struct suspend_blocker suspend_blocker;
+}
+
+init() {
+	suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+
+uninit() {
+	suspend_blocker_destroy(&state->suspend_blocker);
+}
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+	suspend_block(&state->suspend_blocker);
+
+When it no longer needs to run it calls suspend_unblock:
+	suspend_unblock(&state->suspend_blocker);
+
+Calling suspend_block when the suspend blocker is active or suspend_unblock when
+it is not active has no effect. This allows drivers to update their state and
+call suspend suspend_block or suspend_unblock based on the result.
+For instance:
+
+if (list_empty(&state->pending_work))
+	suspend_unblock(&state->suspend_blocker);
+else
+	suspend_block(&state->suspend_blocker);
+
include/linux/suspend_blocker.h new file +60 -0

60 lines not on this page · raw message

kernel/power/Kconfig +10 -0
index 23bd4da..a3587d3 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
 	  Turning OFF this setting is NOT recommended! If in doubt, say Y.
 
+config SUSPEND_BLOCKERS
+	bool "Suspend blockers"
+	depends on PM
+	select RTC_LIB
+	default n
+	---help---
+	  Enable suspend blockers. When user space requests a sleep state
+	  through /sys/power/request_state, the requested sleep state will be
+	  entered when no suspend blockers are active.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 720ea4f..e8c7f85 100644
@@ -6,6 +6,7 @@ endif
 obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
+obj-$(CONFIG_SUSPEND_BLOCKERS)	+= suspend_blocker.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/main.c +61 -1

92 lines not on this page · raw message

kernel/power/power.h +4 -0
index 46b5ec7..2246b3b 100644
@@ -223,3 +223,7 @@ static inline void suspend_thaw_processes(void)
 {
 }
 #endif
+
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+
kernel/power/suspend_blocker.c new file +209 -0

209 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#2 lore raw

PATCH 2/9 PM: suspend_block: Add driver to access suspend blockers from user-space

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

---
 Documentation/power/suspend-blockers.txt |   17 ++++
 include/linux/suspend_block_dev.h        |   25 ++++++
 kernel/power/Kconfig                     |    9 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/user_suspend_blocker.c      |  125 ++++++++++++++++++++++++++++++
 5 files changed, 177 insertions(+), 0 deletions(-)
 create mode 100644 include/linux/suspend_block_dev.h
 create mode 100644 kernel/power/user_suspend_blocker.c
Documentation/power/suspend-blockers.txt +17 -0
index 5a33ed6..9d78d4e 100644
@@ -92,3 +92,20 @@ if (list_empty(&state->pending_work))
 else
 	suspend_block(&state->suspend_blocker);
 
+User-space API
+==============
+
+To create a suspend_blocker from user-space, open the suspend_blocker device:
+    fd = open("/dev/suspend_blocker", O_RDWR | O_CLOEXEC);
+then call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_INIT(strlen(name)), name);
+
+To activate a suspend_blocker call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK);
+
+To unblock call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK);
+
+To destroy the suspend_blocker, close the device:
+    close(fd);
+
include/linux/suspend_block_dev.h new file +25 -0
new file mode 100644
index 0000000..a7c0bf9
@@ -0,0 +1,25 @@
+/* include/linux/suspend_block_dev.h
+ *
+ * Copyright (C) 2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_DEV_H
+#define _LINUX_SUSPEND_BLOCK_DEV_H
+
+#include <linux/ioctl.h>
+
+#define SUSPEND_BLOCKER_IOCTL_INIT(len)		_IOC(_IOC_WRITE, 's', 0, len)
+#define SUSPEND_BLOCKER_IOCTL_BLOCK		_IO('s', 1)
+#define SUSPEND_BLOCKER_IOCTL_UNBLOCK		_IO('s', 3)
+
+#endif
kernel/power/Kconfig +9 -0
index a3587d3..84b423f 100644
@@ -126,6 +126,15 @@ config SUSPEND_BLOCKERS
 	  through /sys/power/request_state, the requested sleep state will be
 	  entered when no suspend blockers are active.
 
+config USER_SUSPEND_BLOCKERS
+	bool "Userspace suspend blockers"
+	depends on SUSPEND_BLOCKERS
+	default y
+	---help---
+	  User-space suspend block api. Creates a misc device with ioctls
+	  to create, block and unblock a suspend_blocker. The suspend_blocker
+	  will be deleted when the device is closed.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index e8c7f85..24ade91 100644
@@ -7,6 +7,7 @@ obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
 obj-$(CONFIG_SUSPEND_BLOCKERS)	+= suspend_blocker.o
+obj-$(CONFIG_USER_SUSPEND_BLOCKERS)	+= user_suspend_blocker.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/user_suspend_blocker.c new file +125 -0

125 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#3 lore raw

PATCH 3/9 PM: suspend_block: Abort task freezing if a suspend_blocker is active.

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting as soon as someone blocks suspend (e.g. from an interrupt handler) improves the worst case wakeup latency.

On an older kernel where task freezing could fail for processes attached to a debugger, this fixed a problem where the device sometimes hung for 20 seconds before the screen turned on.

---
 kernel/power/process.c |   20 ++++++++++++++++----
 1 files changed, 16 insertions(+), 4 deletions(-)
kernel/power/process.c +16 -4
index ca63401..8c7c323 100644
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/freezer.h>
+#include <linux/suspend_blocker.h>
 
 /* 
  * Timeout for stopping processes
@@ -36,6 +37,7 @@ static int try_to_freeze_tasks(bool sig_only)
 	struct timeval start, end;
 	u64 elapsed_csecs64;
 	unsigned int elapsed_csecs;
+	bool wakeup = false;
 
 	do_gettimeofday(&start);
 
@@ -62,6 +64,10 @@ static int try_to_freeze_tasks(bool sig_only)
 		} while_each_thread(g, p);
 		read_unlock(&tasklist_lock);
 		yield();			/* Yield is okay here */
+		if (todo && suspend_is_blocked()) {
+			wakeup = true;
+			break;
+		}
 		if (time_after(jiffies, end_time))
 			break;
 	} while (todo);
@@ -78,10 +84,16 @@ static int try_to_freeze_tasks(bool sig_only)
 		 * but it cleans up leftover PF_FREEZE requests.
 		 */
 		printk("\n");
-		printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
-				"(%d tasks refusing to freeze):\n",
-				elapsed_csecs / 100, elapsed_csecs % 100, todo);
-		show_state();
+		if (wakeup) {
+			printk(KERN_ERR "Freezing of %s aborted\n",
+					sig_only ? "user space " : "tasks ");
+		} else {
+			printk(KERN_ERR
+			       "Freezing of tasks failed after %d.%02d seconds "
+			       "(%d tasks refusing to freeze):\n",
+			       elapsed_csecs / 100, elapsed_csecs % 100, todo);
+			show_state();
+		}
 		read_lock(&tasklist_lock);
 		do_each_thread(g, p) {
 			task_lock(p);
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#4 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Hi!

Quoted 2 lines

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting

Please fix try_to_freeze not to take significant time rather than this...

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#5 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 7 lines · Pavel Machek

Hi!

Quoted 2 lines

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting

Please fix try_to_freeze not to take significant time rather than this...

I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible sleep in the kernel can delay the task freezing and there is no point in completing this when we know suspend will fail.

Signature · 1 line
Arve Hjønnevåg
#6 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 6 lines · Arve Hj?nnev?g
Quoted 5 lines · Pavel Machek

Hi!

Quoted 2 lines

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting

Quoted 7 lines
Quoted 2 lines

Please fix try_to_freeze not to take significant time rather than this...

I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible

If the code runs for 20 seconds, it is a bug to be fixed.

IOW the patch should not be needed when the bugs are fixed. You should not need it now.

Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.

For now, it just makes stuff harder to review.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#7 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 10 lines · Pavel Machek
Quoted 9 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek

Hi!

Quoted 2 lines

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting

Please fix try_to_freeze not to take significant time rather than this...

Quoted 6 lines
Quoted 4 lines

I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible

If the code runs for 20 seconds, it is a bug to be fixed.

The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.

Quoted 8 lines

IOW the patch should not be needed when the bugs are fixed. You should not need it now.

Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.

It can take a significant amount of time. It has to wait for every thread it signalled to freeze which seems to be every user-space thread. On my device, with 200 threads, this took less than 10ms half the time, up to 460ms in the worst case.

Quoted 1 line

For now, it just makes stuff harder to review.

I think this patch is needed whether there are bugs or not, to ensure low latency wakeup.

Quoted 5 lines

                                                                       Pavel --
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Signature · 1 line
Arve Hjønnevåg
#8 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Hi.

Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek

If the code runs for 20 seconds, it is a bug to be fixed.

The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.

I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).

In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 - when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.

Regards,

Nigel

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#9 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

2009/5/7 Nigel Cunningham <[email protected]>:

Quoted 17 lines

Hi.

Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek

If the code runs for 20 seconds, it is a bug to be fixed.

The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.

Quoted 6 lines

I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).

In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -

One second is to long.

Quoted 2 lines

when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.

This patch does nothing with the 20 second timeout.

Signature · 1 line
Arve Hjønnevåg
#10 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Hi.

Quoted 18 lines · Arve Hjønnevåg

2009/5/7 Nigel Cunningham <[email protected]>:

Quoted 17 lines

Hi.

Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek

If the code runs for 20 seconds, it is a bug to be fixed.

The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.

Quoted 8 lines
Quoted 6 lines

I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).

In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -

One second is to long.

I agree. But a one second timeout is still better than a 20s timeout.

Quoted 4 lines
Quoted 2 lines

when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.

This patch does nothing with the 20 second timeout.

I know. Perhaps we should do something with it, though.

Nigel

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#11 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 30 lines · Nigel Cunningham

Hi.

Quoted 18 lines · Arve Hjønnevåg

2009/5/7 Nigel Cunningham <[email protected]>:

Quoted 17 lines

Hi.

Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek

If the code runs for 20 seconds, it is a bug to be fixed.

The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.

Quoted 8 lines
Quoted 6 lines

I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).

In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -

One second is to long.

Quoted 8 lines

I agree. But a one second timeout is still better than a 20s timeout.

Quoted 4 lines
Quoted 2 lines

when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.

This patch does nothing with the 20 second timeout.

I know. Perhaps we should do something with it, though.

I tried some time ago, but it didn't really work well.

The timeout is actually a workaround for the problem that we don't really know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

Now, I think the Arve's approach is reasonable. If we know in advace that we're not going to suspend, it's better to stop the freezing as soon as possible.

Thanks,
Rafael
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#12 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

What were the circumstances in which freezing could take 20s?

Quoted 3 lines

Now, I think the Arve's approach is reasonable. If we know in advace that we're not going to suspend, it's better to stop the freezing as soon as possible.

Agreed.

Regards,

Nigel

#13 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 11 lines · Nigel Cunningham

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

Quoted 1 line

What were the circumstances in which freezing could take 20s?

Compiling the kernel with "make -j<big number>" on a dual core system IIRC.

Generally, the situation in which there are many runnable tasks and new tasks come and go etc. I haven't repeated this benchmark recently, though, so it's probably worth doing again.

Which has a little to do with the $subject patch IMO, because I think that it's reasonable to stop freezing tasks as soon as we know that it won't be necessary anyway.

Thanks,
Rafael

#14 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Hi.

Quoted 16 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

Quoted 1 line

What were the circumstances in which freezing could take 20s?

Compiling the kernel with "make -j<big number>" on a dual core system IIRC.

Quoted 7 lines

Generally, the situation in which there are many runnable tasks and new tasks come and go etc. I haven't repeated this benchmark recently, though, so it's probably worth doing again.

Which has a little to do with the $subject patch IMO, because I think that it's reasonable to stop freezing tasks as soon as we know that it won't be necessary anyway.

Yes, but it's still good to know.

Regards,

Nigel

#15 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

In reply to Rafael J. Wysocki
Quoted 12 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

Quoted 3 lines
Quoted 1 line

What were the circumstances in which freezing could take 20s?

Compiling the kernel with "make -j<big number>" on a dual core system IIRC.

IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#16 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 13 lines · Pavel Machek
Quoted 12 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

What were the circumstances in which freezing could take 20s?

Compiling the kernel with "make -j<big number>" on a dual core system IIRC.

IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".

No, it appeared after a number of experiments I carried out a couple of years ago. :-)

Best,
Rafael

#17 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

Quoted 16 lines · Rafael J. Wysocki
Quoted 15 lines · Pavel Machek
Quoted 14 lines · Rafael J. Wysocki
Quoted 12 lines · Nigel Cunningham

Hi.

Quoted 7 lines · Rafael J. Wysocki

The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.

What were the circumstances in which freezing could take 20s?

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

Compiling the kernel with "make -j<big number>" on a dual core system IIRC.

IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".

No, it appeared after a number of experiments I carried out a couple of years ago. :-)

Ok, that was the "IIRC" part :-).
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#18 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

In reply to Arve Hjønnevåg

Hi!

Quoted 8 lines
Quoted 7 lines

IOW the patch should not be needed when the bugs are fixed. You should not need it now.

Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.

Quoted 4 lines

It can take a significant amount of time. It has to wait for every thread it signalled to freeze which seems to be every user-space thread. On my device, with 200 threads, this took less than 10ms half the time, up to 460ms in the worst case.

Ok, 460ms in the worst case is good reason to apply this patch, I agree.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#19 lore raw

Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

In reply to Pavel Machek
Quoted 7 lines · Pavel Machek

Hi!

Quoted 2 lines

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting

Please fix try_to_freeze not to take significant time rather than this...

FYI, I agree with this patch.

Best,
Rafael

#20 lore raw

PATCH 4/9 Input: Block suspend while event queue is not empty.

In reply to Arve Hjønnevåg

Add an ioctl, EVIOCSSUSPENDBLOCK, to enable a suspend_blocker that will block suspend while the event queue is not empty. This allows userspace code to process input events while the device appears to be asleep.

---
 drivers/input/evdev.c |   22 ++++++++++++++++++++++
 include/linux/input.h |    3 +++
 2 files changed, 25 insertions(+), 0 deletions(-)
drivers/input/evdev.c +22 -0
index 7a7a026..0bb670f 100644
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/major.h>
 #include <linux/device.h>
+#include <linux/suspend_blocker.h>
 #include "input-compat.h"
 
 struct evdev {
@@ -43,6 +44,8 @@ struct evdev_client {
 	struct fasync_struct *fasync;
 	struct evdev *evdev;
 	struct list_head node;
+	struct suspend_blocker suspend_blocker;
+	bool use_suspend_blocker;
 };
 
 static struct evdev *evdev_table[EVDEV_MINORS];
@@ -55,6 +58,8 @@ static void evdev_pass_event(struct evdev_client *client,
 	 * Interrupts are disabled, just acquire the lock
 	 */
 	spin_lock(&client->buffer_lock);
+	if (client->use_suspend_blocker)
+		suspend_block(&client->suspend_blocker);
 	client->buffer[client->head++] = *event;
 	client->head &= EVDEV_BUFFER_SIZE - 1;
 	spin_unlock(&client->buffer_lock);
@@ -233,6 +238,8 @@ static int evdev_release(struct inode *inode, struct file *file)
 	mutex_unlock(&evdev->mutex);
 
 	evdev_detach_client(evdev, client);
+	if (client->use_suspend_blocker)
+		suspend_blocker_destroy(&client->suspend_blocker);
 	kfree(client);
 
 	evdev_close_device(evdev);
@@ -332,6 +339,8 @@ static int evdev_fetch_next_event(struct evdev_client *client,
 	if (have_event) {
 		*event = client->buffer[client->tail++];
 		client->tail &= EVDEV_BUFFER_SIZE - 1;
+		if (client->use_suspend_blocker && client->head == client->tail)
+			suspend_unblock(&client->suspend_blocker);
 	}
 
 	spin_unlock_irq(&client->buffer_lock);
@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 		else
 			return evdev_ungrab(evdev, client);
 
+	case EVIOCGSUSPENDBLOCK:
+		return put_user(client->use_suspend_blocker, ip);
+
+	case EVIOCSSUSPENDBLOCK:
+		spin_lock_irq(&client->buffer_lock);
+		if (!client->use_suspend_blocker && p)
+			suspend_blocker_init(&client->suspend_blocker, "evdev");
+		else if (client->use_suspend_blocker && !p)
+			suspend_blocker_destroy(&client->suspend_blocker);
+		client->use_suspend_blocker = !!p;
+		spin_unlock_irq(&client->buffer_lock);
+		return 0;
+
 	default:
 
 		if (_IOC_TYPE(cmd) != 'E')
include/linux/input.h +3 -0
index 6b28048..e091ea8 100644
@@ -81,6 +81,9 @@ struct input_absinfo {
 
 #define EVIOCGRAB		_IOW('E', 0x90, int)			/* Grab/Release device */
 
+#define EVIOCGSUSPENDBLOCK	_IOR('E', 0x91, int)			/* get suspend block enable */
+#define EVIOCSSUSPENDBLOCK	_IOW('E', 0x91, int)			/* set suspend block enable */
+
 /*
  * Event types
  */
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#21 lore raw

Re: [PATCH 4/9] Input: Block suspend while event queue is not empty.

Quoted 6 lines

Add an ioctl, EVIOCSSUSPENDBLOCK, to enable a suspend_blocker that will block suspend while the event queue is not empty. This allows userspace code to process input events while the device appears to be asleep.

Looks ok to me, but I guess you should cc input maintainers.

Quoted 6 lines
drivers/input/evdev.c +2 -0
@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 		else
 			return evdev_ungrab(evdev, client);
 
+	case EVIOCGSUSPENDBLOCK:
+		return put_user(client->use_suspend_blocker, ip);

drivers/input/evdev.c static long evdev_do_ioctl(struct file *file, unsigned int cmd, · line 605

Quoted 10 lines
drivers/input/evdev.c +10 -0
+
+	case EVIOCSSUSPENDBLOCK:
+		spin_lock_irq(&client->buffer_lock);
+		if (!client->use_suspend_blocker && p)
+			suspend_blocker_init(&client->suspend_blocker, "evdev");
+		else if (client->use_suspend_blocker && !p)
+			suspend_blocker_destroy(&client->suspend_blocker);
+		client->use_suspend_blocker = !!p;
+		spin_unlock_irq(&client->buffer_lock);
+		return 0;

This returns 0 even when you destroy already destroyed blocker (etc). Is that ok?

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#22 lore raw

Re: [PATCH 4/9] Input: Block suspend while event queue is not empty.

Quoted 8 lines · Pavel Machek
Quoted 6 lines

Add an ioctl, EVIOCSSUSPENDBLOCK, to enable a suspend_blocker that will block suspend while the event queue is not empty. This allows userspace code to process input events while the device appears to be asleep.

Looks ok to  me, but I guess you should cc input maintainers.

OK.

Quoted 5 lines
Quoted 5 lines
(quoted diff) +0 -0
@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,

              else
                      return evdev_ungrab(evdev, client);

Quoted 15 lines
Quoted 4 lines

+     case EVIOCGSUSPENDBLOCK:
+             return put_user(client->use_suspend_blocker, ip); +
+     case EVIOCSSUSPENDBLOCK:

Quoted 8 lines

+             spin_lock_irq(&client->buffer_lock);
+             if (!client->use_suspend_blocker && p)
+                     suspend_blocker_init(&client->suspend_blocker, "evdev");
+             else if (client->use_suspend_blocker && !p)
+                     suspend_blocker_destroy(&client->suspend_blocker);
+             client->use_suspend_blocker = !!p;
+             spin_unlock_irq(&client->buffer_lock);
+             return 0;

This returns 0 even when you destroy already destroyed blocker (etc). Is that ok?

Yes. If events did not block suspend before the call, they still do not block suspend after the call, so the requested state was reached.

Signature · 1 line
Arve Hjønnevåg
#23 lore raw

PATCH 5/9 PM: suspend_block: Switch to list of active and inactive suspend blockers

In reply to Arve Hjønnevåg

This allows active suspend blockers to be listed

---
 include/linux/suspend_blocker.h |    6 ++-
 kernel/power/suspend_blocker.c  |   85 +++++++++++++++++++++++++++-----------
 2 files changed, 65 insertions(+), 26 deletions(-)
include/linux/suspend_blocker.h +5 -1
index 21689cd..1faa433 100755
@@ -16,8 +16,11 @@
 #ifndef _LINUX_SUSPEND_BLOCKER_H
 #define _LINUX_SUSPEND_BLOCKER_H
 
+#include <linux/list.h>
+
 /**
  * struct suspend_blocker - the basic suspend_blocker structure
+ * @link:	List entry for active or inactive list.
  * @flags:	Tracks initialized and active state.
  * @name:	Name used for debugging.
  *
@@ -29,7 +32,8 @@
 
 struct suspend_blocker {
 #ifdef CONFIG_SUSPEND_BLOCKERS
-	atomic_t            flags;
+	struct list_head    link;
+	int                 flags;
 	const char         *name;
 #endif
 };
kernel/power/suspend_blocker.c +60 -25

162 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#24 lore raw

PATCH 6/9 PM: suspend_block: Add debugfs file

Report active and inactive suspend blockers in
/sys/kernel/debug/suspend_blockers.

---
 kernel/power/suspend_blocker.c |   44 ++++++++++++++++++++++++++++++++++++++-
 1 files changed, 42 insertions(+), 2 deletions(-)
kernel/power/suspend_blocker.c +42 -2
index cab9e9a..ce87c65 100644
@@ -17,6 +17,7 @@
 #include <linux/rtc.h>
 #include <linux/suspend.h>
 #include <linux/suspend_blocker.h>
+#include <linux/debugfs.h>
 #include "power.h"
 
 enum {
@@ -41,6 +42,7 @@ struct workqueue_struct *suspend_work_queue;
 struct suspend_blocker main_suspend_blocker;
 static suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
 static bool enable_suspend_blockers;
+static struct dentry *suspend_blocker_stats_dentry;
 
 #define pr_info_time(fmt, args...) \
 	do { \
@@ -54,6 +56,21 @@ static bool enable_suspend_blockers;
 			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec); \
 	} while (0);
 
+static int suspend_blocker_stats_show(struct seq_file *m, void *unused)
+{
+	unsigned long irqflags;
+	struct suspend_blocker *blocker;
+
+	seq_puts(m, "name\tactive\n");
+	spin_lock_irqsave(&list_lock, irqflags);
+	list_for_each_entry(blocker, &inactive_blockers, link)
+		seq_printf(m, "\"%s\"\t0\n", blocker->name);
+	list_for_each_entry(blocker, &active_blockers, link)
+		seq_printf(m, "\"%s\"\t1\n", blocker->name);
+	spin_unlock_irqrestore(&list_lock, irqflags);
+	return 0;
+}
+
 static void print_active_blockers_locked(void)
 {
 	struct suspend_blocker *blocker;
@@ -101,8 +118,8 @@ static DECLARE_WORK(suspend_work, suspend_worker);
 /**
  * suspend_blocker_init() - Initialize a suspend blocker
  * @blocker:	The suspend blocker to initialize.
- * @name:	The name of the suspend blocker to show in debug messages.
- *
+ * @name:	The name of the suspend blocker to show in debug messages and
+ *		/sys/kernel/debug/suspend_blockers.
  * The suspend blocker struct and name must not be freed before calling
  * suspend_blocker_destroy.
  */
@@ -230,6 +247,19 @@ void request_suspend_state(suspend_state_t state)
 	spin_unlock_irqrestore(&state_lock, irqflags);
 }
 
+static int suspend_blocker_stats_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, suspend_blocker_stats_show, NULL);
+}
+
+static const struct file_operations suspend_blocker_stats_fops = {
+	.owner = THIS_MODULE,
+	.open = suspend_blocker_stats_open,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = single_release,
+};
+
 static int __init suspend_block_init(void)
 {
 	suspend_work_queue = create_singlethread_workqueue("suspend");
@@ -241,4 +271,14 @@ static int __init suspend_block_init(void)
 	return 0;
 }
 
+static int __init suspend_block_postcore_init(void)
+{
+	if (!suspend_work_queue)
+		return 0;
+	suspend_blocker_stats_dentry = debugfs_create_file("suspend_blockers",
+			S_IRUGO, NULL, NULL, &suspend_blocker_stats_fops);
+	return 0;
+}
+
 core_initcall(suspend_block_init);
+postcore_initcall(suspend_block_postcore_init);
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#25 lore raw

PATCH 7/9 PM: suspend_block: Add suspend_blocker stats

Report suspend block stats in /sys/kernel/debug/suspend_blockers.

---
 include/linux/suspend_blocker.h |   21 ++++-
 kernel/power/Kconfig            |    7 ++
 kernel/power/main.c             |    4 +-
 kernel/power/power.h            |    6 +-
 kernel/power/suspend_blocker.c  |  190 +++++++++++++++++++++++++++++++++++++--
 5 files changed, 218 insertions(+), 10 deletions(-)
include/linux/suspend_blocker.h +20 -1
index 1faa433..3bb8a6a 100755
@@ -17,12 +17,21 @@
 #define _LINUX_SUSPEND_BLOCKER_H
 
 #include <linux/list.h>
+#include <linux/ktime.h>
 
 /**
  * struct suspend_blocker - the basic suspend_blocker structure
  * @link:	List entry for active or inactive list.
- * @flags:	Tracks initialized and active state.
+ * @flags:	Tracks initialized, active and stats state.
  * @name:	Name used for debugging.
+ * @count:	Number of times this blocker has been deacivated
+ * @wakeup_count: Number of times this blocker was the first to block suspend
+ *		after resume.
+ * @total_time:	Total time this suspend blocker has prevented suspend.
+ * @prevent_suspend_time: Time this suspend blocker has prevented suspend while
+ *		user-space requested suspend.
+ * @max_time:	Max time this suspend blocker has been continuously active
+ * @last_time:	Monotonic clock when the active state last changed.
  *
  * When a suspend_blocker is active it prevents the system from entering
  * suspend.
@@ -35,6 +44,16 @@ struct suspend_blocker {
 	struct list_head    link;
 	int                 flags;
 	const char         *name;
+#ifdef CONFIG_SUSPEND_BLOCKER_STATS
+	struct {
+		int             count;
+		int             wakeup_count;
+		ktime_t         total_time;
+		ktime_t         prevent_suspend_time;
+		ktime_t         max_time;
+		ktime_t         last_time;
+	} stat;
+#endif
 #endif
 };
 
kernel/power/Kconfig +7 -0
index 84b423f..44bfaeb 100644
@@ -126,6 +126,13 @@ config SUSPEND_BLOCKERS
 	  through /sys/power/request_state, the requested sleep state will be
 	  entered when no suspend blockers are active.
 
+config SUSPEND_BLOCKER_STATS
+	bool "Suspend block stats"
+	depends on SUSPEND_BLOCKERS
+	default y
+	---help---
+	  Report suspend block stats in /sys/kernel/debug/suspend_blockers
+
 config USER_SUSPEND_BLOCKERS
 	bool "Userspace suspend blockers"
 	depends on SUSPEND_BLOCKERS
kernel/power/main.c +3 -1
index 1899cda..022acca 100644
@@ -322,8 +322,10 @@ static int suspend_enter(suspend_state_t state)
 
 	error = sysdev_suspend(PMSG_SUSPEND);
 	if (!error) {
-		if (!suspend_is_blocked() && !suspend_test(TEST_CORE))
+		if (!suspend_is_blocked() && !suspend_test(TEST_CORE)) {
+			about_to_enter_suspend();
 			error = suspend_ops->enter(state);
+		}
 		sysdev_resume();
 	}
 
kernel/power/power.h +5 -1
index 2246b3b..5c30fb4 100644
@@ -226,4 +226,8 @@ static inline void suspend_thaw_processes(void)
 
 /* kernel/power/suspend_block.c */
 void request_suspend_state(suspend_state_t state);
-
+#ifdef CONFIG_SUSPEND_BLOCKER_STATS
+void about_to_enter_suspend(void);
+#else
+static inline void about_to_enter_suspend(void) {}
+#endif
kernel/power/suspend_blocker.c +183 -7

265 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#26 lore raw

PATCH 8/9 PM: suspend_block: Add timeout support.

Add suspend_block_timeout to block suspend for a limited time.

---
 Documentation/power/suspend-blockers.txt |   10 ++
 include/linux/suspend_blocker.h          |    7 +-
 kernel/power/suspend_blocker.c           |  235 +++++++++++++++++++++++++----
 3 files changed, 218 insertions(+), 34 deletions(-)
Documentation/power/suspend-blockers.txt +10 -0
index 9d78d4e..bc9d57a 100644
@@ -92,6 +92,16 @@ if (list_empty(&state->pending_work))
 else
 	suspend_block(&state->suspend_blocker);
 
+A driver can also call suspend_block_timeout to release the suspend_blocker
+after a delay:
+	suspend_block_timeout(&state->suspend_blocker, HZ);
+
+This works whether the suspend_blocker is already active or not. It is useful if
+the driver woke up other parts of the system that do not use suspend_blockers
+but still need to run. Avoid this when possible, since it will waste power
+if the timeout is long or may fail to finish needed work if the timeout is
+short. Calling suspend_block or suspend_unblock will cancel the timeout.
+
 User-space API
 ==============
 
include/linux/suspend_blocker.h +6 -1
index 3bb8a6a..e3ae136 100755
@@ -22,8 +22,9 @@
 /**
  * struct suspend_blocker - the basic suspend_blocker structure
  * @link:	List entry for active or inactive list.
- * @flags:	Tracks initialized, active and stats state.
+ * @flags:	Tracks initialized, active, stats and autoexpire state.
  * @name:	Name used for debugging.
+ * @expires:	Time, in jiffies, to unblock suspend.
  * @count:	Number of times this blocker has been deacivated
  * @wakeup_count: Number of times this blocker was the first to block suspend
  *		after resume.
@@ -44,9 +45,11 @@ struct suspend_blocker {
 	struct list_head    link;
 	int                 flags;
 	const char         *name;
+	unsigned long       expires;
 #ifdef CONFIG_SUSPEND_BLOCKER_STATS
 	struct {
 		int             count;
+		int             expire_count;
 		int             wakeup_count;
 		ktime_t         total_time;
 		ktime_t         prevent_suspend_time;
@@ -62,6 +65,7 @@ struct suspend_blocker {
 void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
 void suspend_blocker_destroy(struct suspend_blocker *blocker);
 void suspend_block(struct suspend_blocker *blocker);
+void suspend_block_timeout(struct suspend_blocker *blocker, long timeout);
 void suspend_unblock(struct suspend_blocker *blocker);
 bool suspend_blocker_is_active(struct suspend_blocker *blocker);
 bool suspend_is_blocked(void);
@@ -72,6 +76,7 @@ static inline void suspend_blocker_init(struct suspend_blocker *blocker,
 					const char *name) {}
 static inline void suspend_blocker_destroy(struct suspend_blocker *blocker) {}
 static inline void suspend_block(struct suspend_blocker *blocker) {}
+static inline void suspend_block_timeout(struct suspend_blocker *bl, long t) {}
 static inline void suspend_unblock(struct suspend_blocker *blocker) {}
 static inline bool suspend_blocker_is_active(struct suspend_blocker *bl)
 								{ return 0; }
kernel/power/suspend_blocker.c +202 -33

402 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#27 lore raw

PATCH 9/9 PM: suspend_block: Add timeout support to user-space suspend_blockers

This also allows a grace period to be set where suspend is blocked for a while if a user-space suspend_blocker is destroyed while it was active.

---
 Documentation/power/suspend-blockers.txt |    7 +++++++
 include/linux/suspend_block_dev.h        |    1 +
 kernel/power/user_suspend_blocker.c      |   23 +++++++++++++++++++++++
 3 files changed, 31 insertions(+), 0 deletions(-)
Documentation/power/suspend-blockers.txt +7 -0
index bc9d57a..3612794 100644
@@ -112,6 +112,8 @@ then call:
 
 To activate a suspend_blocker call:
     ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK);
+or
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT, &timespec_timeout);
 
 To unblock call:
     ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK);
@@ -119,3 +121,8 @@ To unblock call:
 To destroy the suspend_blocker, close the device:
     close(fd);
 
+A module parameter, unclean_exit_grace_period, can be set to allow servers
+some time to restart if they crash with an active suspend_blocker. If the
+process dies or the device is closed while the suspend_blocker is active, a
+suspend_blocker will be held for the number of seconds specified.
+
include/linux/suspend_block_dev.h +1 -0
index a7c0bf9..cff4943 100644
@@ -20,6 +20,7 @@
 
 #define SUSPEND_BLOCKER_IOCTL_INIT(len)		_IOC(_IOC_WRITE, 's', 0, len)
 #define SUSPEND_BLOCKER_IOCTL_BLOCK		_IO('s', 1)
+#define SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT	_IOW('s', 2, struct timespec)
 #define SUSPEND_BLOCKER_IOCTL_UNBLOCK		_IO('s', 3)
 
 #endif
kernel/power/user_suspend_blocker.c +23 -0
index 69b3ddb..b853f66 100644
@@ -26,7 +26,12 @@ enum {
 static int debug_mask = DEBUG_FAILURE;
 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
 
+static int unclean_exit_grace_period;
+module_param_named(unclean_exit_grace_period, unclean_exit_grace_period, int,
+						S_IRUGO | S_IWUSR | S_IWGRP);
+
 static DEFINE_MUTEX(ioctl_lock);
+static struct suspend_blocker unclean_exit_suspend_blocker;
 
 struct user_suspend_blocker {
 	struct suspend_blocker	blocker;
@@ -58,6 +63,8 @@ static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
 {
 	void __user *arg = (void __user *)_arg;
 	struct user_suspend_blocker *bl;
+	struct timespec ts;
+	unsigned long timeout;
 	long ret;
 
 	mutex_lock(&ioctl_lock);
@@ -75,6 +82,15 @@ static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
 		suspend_block(&bl->blocker);
 		ret = 0;
 		break;
+	case SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT:
+		if (copy_from_user(&ts, arg, sizeof(ts))) {
+			ret = -EFAULT;
+			goto done;
+		}
+		timeout  = timespec_to_jiffies(&ts);
+		suspend_block_timeout(&bl->blocker, timeout);
+		ret = 0;
+		break;
 	case SUSPEND_BLOCKER_IOCTL_UNBLOCK:
 		suspend_unblock(&bl->blocker);
 		ret = 0;
@@ -95,6 +111,10 @@ static int user_suspend_blocker_release(struct inode *inode, struct file *file)
 	struct user_suspend_blocker *bl = file->private_data;
 	if (!bl)
 		return 0;
+	if (suspend_blocker_is_active(&bl->blocker) &&
+	    unclean_exit_grace_period)
+		suspend_block_timeout(&unclean_exit_suspend_blocker,
+					unclean_exit_grace_period * HZ);
 	suspend_blocker_destroy(&bl->blocker);
 	kfree(bl);
 	return 0;
@@ -113,12 +133,15 @@ struct miscdevice user_suspend_blocker_device = {
 
 static int __init user_suspend_blocker_init(void)
 {
+	suspend_blocker_init(&unclean_exit_suspend_blocker,
+				"user-unclean-exit");
 	return misc_register(&user_suspend_blocker_device);
 }
 
 static void __exit user_suspend_blocker_exit(void)
 {
 	misc_deregister(&user_suspend_blocker_device);
+	suspend_blocker_destroy(&unclean_exit_suspend_blocker);
 }
 
 module_init(user_suspend_blocker_init);
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#28 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

In reply to Arve Hjønnevåg

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Rafael proposed write() interface. I don't think you answered that.

Quoted 4 lines
kernel/power/user_suspend_blocker.c new file +4 -0
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+				 size_t name_len)
+{
+	struct user_suspend_blocker *bl;

kernel/power/user_suspend_blocker.c line 49

Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +10 -0
+	if (file->private_data)
+		return -EBUSY;
+	bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);
+	if (!bl)
+		return -ENOMEM;
+	if (copy_from_user(bl->name, name, name_len))
+		goto err_fault;
+	suspend_blocker_init(&bl->blocker, bl->name);
+	file->private_data = bl;
+	return 0;

kzalloc on user-supplied argument. Sounds like bad idea.

Aha. And probably integer overflow in the same line. Ouch.

Plus you actually 'trust' the string from userspace. Someone passes "evdev" there and can masquerade as a part of kernel.

kernel/power/user_suspend_blocker.c line 101

Quoted 9 lines
kernel/power/user_suspend_blocker.c new file +9 -0
+static int user_suspend_blocker_release(struct inode *inode, struct file *file)
+{
+	struct user_suspend_blocker *bl = file->private_data;
+	if (!bl)
+		return 0;
+	suspend_blocker_destroy(&bl->blocker);
+	kfree(bl);
+	return 0;
+}

What happens if someone does dup() on such file descriptor?

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#29 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 9 lines · Pavel Machek

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Rafael proposed write() interface. I don't think you answered that.

I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.

Quoted 18 lines
Quoted 5 lines
kernel/power/user_suspend_blocker.c new file +4 -0
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+                              size_t name_len)
+{
+     struct user_suspend_blocker *bl;

kernel/power/user_suspend_blocker.c line 49

Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +10 -0
+     if (file->private_data)
+             return -EBUSY;
+     bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);
+     if (!bl)
+             return -ENOMEM;
+     if (copy_from_user(bl->name, name, name_len))
+             goto err_fault;
+     suspend_blocker_init(&bl->blocker, bl->name);
+     file->private_data = bl;
+     return 0;

kzalloc on user-supplied argument. Sounds like bad idea.

Quoted 2 lines

Aha. And probably integer overflow in the same line. Ouch.

The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?

Quoted 2 lines

Plus you actually 'trust' the string from userspace. Someone passes "evdev" there and can masquerade as a part of kernel.

Yes. I could add a prefix to userspace names, but it did not seem worth the effort since the name is not used as a key for anything.

Quoted 13 lines

kernel/power/user_suspend_blocker.c line 101

Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +9 -0
+static int user_suspend_blocker_release(struct inode *inode, struct file *file)
+{
+     struct user_suspend_blocker *bl = file->private_data;
+     if (!bl)
+             return 0;
+     suspend_blocker_destroy(&bl->blocker);
+     kfree(bl);
+     return 0;
+}

What happens if someone does dup() on such file descriptor?

Then you have two file descriptors pointing to the same suspend blocker. Release is called when the last reference goes away.

Signature · 1 line
Arve Hjønnevåg
#30 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Quoted 6 lines
Quoted 2 lines

Rafael proposed write() interface. I don't think you answered that.

I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.

Or perhaps just use "userspace/%d" % pid as a name?

1) can't be faked that trivially

2) small / mostly fixed size

3) can use nicer write protocol?

Quoted 7 lines
Quoted 4 lines

kzalloc on user-supplied argument. Sounds like bad idea.

Aha. And probably integer overflow in the same line. Ouch.

The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?

16K of unswappable kernel memory for name is a bit too much, yes.

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#31 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 9 lines · Pavel Machek
Quoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Quoted 8 lines
Quoted 6 lines
Quoted 2 lines

Rafael proposed write() interface. I don't think you answered that.

I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.

Or perhaps just use "userspace/%d" % pid as a name?

This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.

Quoted 2 lines

1) can't be faked that trivially

I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.

Quoted 5 lines

2) small / mostly fixed size

3) can use nicer write protocol?

I don't think a write protocol is nicer. "ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val = 1; write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".

Quoted 9 lines
Quoted 7 lines
Quoted 4 lines

kzalloc on user-supplied argument. Sounds like bad idea.

Aha. And probably integer overflow in the same line. Ouch.

The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?

16K of unswappable kernel memory for name is a bit too much, yes.

What if I just truncate it to NAME_MAX.

Signature · 1 line
Arve Hjønnevåg
#32 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 49 lines · Arve Hjønnevåg
Quoted 9 lines · Pavel Machek
Quoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Quoted 8 lines
Quoted 6 lines
Quoted 2 lines

Rafael proposed write() interface. I don't think you answered that.

I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.

Or perhaps just use "userspace/%d" % pid as a name?

This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.

Quoted 2 lines

1) can't be faked that trivially

I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.

Quoted 5 lines

2) small / mostly fixed size

3) can use nicer write protocol?

I don't think a write protocol is nicer. "ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val = 1; write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".

Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

kzalloc on user-supplied argument. Sounds like bad idea.

Aha. And probably integer overflow in the same line. Ouch.

Quoted 6 lines
Quoted 4 lines
Quoted 2 lines

The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?

16K of unswappable kernel memory for name is a bit too much, yes.

What if I just truncate it to NAME_MAX.

My main concern with the ioctl() interface is that you're adding a device file just in order to have the ioctl()s available. Usually, however, a device file's purpose is to implement file operations (open, close, read, write), while ioctl()s are used for doing things that the file operations are not suitable for.

So, if your device only implements open(), close() and ioctl(), this is an indication that there's something wrong with the interface, because it doesn't do what one would generally expect it to do (ie. smells like an abuse). That's why I think it would be better to use read() and write() instead of ioctl().

Of course, there also is a problem that people generally don't like adding new ioctl()s without a _really_ good reason.

Thanks,
Rafael

#33 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

2009/5/8 Rafael J. Wysocki <[email protected]>:

Quoted 55 lines · Arve Hjønnevåg
Quoted 54 lines · Pavel Machek
Quoted 9 lines · Arve Hj?nnev?g
Quoted 8 lines · Pavel Machek
Quoted 7 lines

Hi!

Quoted 4 lines

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

Quoted 8 lines
Quoted 6 lines
Quoted 2 lines

Rafael proposed write() interface. I don't think you answered that.

I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.

Or perhaps just use "userspace/%d" % pid as a name?

This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.

Quoted 2 lines

1) can't be faked that trivially

I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.

Quoted 5 lines

2) small / mostly fixed size

3) can use nicer write protocol?

I don't think a write protocol is nicer. "ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val = 1; write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".

Quoted 9 lines
Quoted 7 lines
Quoted 4 lines

kzalloc on user-supplied argument. Sounds like bad idea.

Aha. And probably integer overflow in the same line. Ouch.

The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?

16K of unswappable kernel memory for name is a bit too much, yes.

Quoted 7 lines
Quoted 1 line

What if I just truncate it to NAME_MAX.

My main concern with the ioctl() interface is that you're adding a device file just in order to have the ioctl()s available.  Usually, however, a device file's purpose is to implement file operations (open, close, read, write), while ioctl()s are used for doing things that the file operations are not suitable for.

In this case, we are adding a device file to get close (release).

Quoted 4 lines

So, if your device only implements open(), close() and ioctl(), this is an indication that there's something wrong with the interface, because it doesn't do what one would generally expect it to do (ie. smells like an abuse).  That's why I think it would be better to use read() and write() instead of ioctl().

It not not clear to me how putting a control interface on top of read and write is any less abusive.

Quoted 2 lines

Of course, there also is a problem that people generally don't like adding new ioctl()s without a _really_ good reason.

ioctls are better suited for issuing commands than read/write.

Signature · 1 line
Arve Hjønnevåg
#34 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

In reply to Arve Hjønnevåg
Quoted 13 lines · Arve Hj??nnev??g

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

kernel/power/user_suspend_blocker.c new file +7 -0
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+				 size_t name_len)
+{
+	struct user_suspend_blocker *bl;
+	if (file->private_data)
+		return -EBUSY;
+	bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);

...

kernel/power/user_suspend_blocker.c line 67

Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12 -0
+static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
+				unsigned long _arg)
+{
+	void __user *arg = (void __user *)_arg;
+	struct user_suspend_blocker *bl;
+	long ret;
+
+	mutex_lock(&ioctl_lock);
+	if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_INIT(0)) {
+		ret = create_user_suspend_blocker(file, arg, _IOC_SIZE(cmd));
+		goto done;
+	}

Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#35 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 15 lines · Pavel Machek
Quoted 13 lines · Arve Hj??nnev??g

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

kernel/power/user_suspend_blocker.c new file +7 -0
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+                              size_t name_len)
+{
+     struct user_suspend_blocker *bl;
+     if (file->private_data)
+             return -EBUSY;
+     bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);

...

Quoted 15 lines

kernel/power/user_suspend_blocker.c line 67

Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12 -0
+static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long _arg)
+{
+     void __user *arg = (void __user *)_arg;
+     struct user_suspend_blocker *bl;
+     long ret;
+
+     mutex_lock(&ioctl_lock);
+     if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_INIT(0)) {
+             ret = create_user_suspend_blocker(file, arg, _IOC_SIZE(cmd));
+             goto done;
+     }

Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!

This is not uncommon. _IOC encodes the size of the argument, and if this is not a fixed size, then the raw ioctl number change based on the size passed in. Look at input.h is you want other examples of this.

Signature · 1 line
Arve Hjønnevåg
#36 lore raw

Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space

Quoted 32 lines · Arve Hj?nnev?g
Quoted 15 lines · Pavel Machek
Quoted 13 lines · Arve Hj??nnev??g

Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

kernel/power/user_suspend_blocker.c new file +7 -0
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+                              size_t name_len)
+{
+     struct user_suspend_blocker *bl;
+     if (file->private_data)
+             return -EBUSY;
+     bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);

...

Quoted 15 lines

kernel/power/user_suspend_blocker.c line 67

Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12 -0
+static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long _arg)
+{
+     void __user *arg = (void __user *)_arg;
+     struct user_suspend_blocker *bl;
+     long ret;
+
+     mutex_lock(&ioctl_lock);
+     if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_INIT(0)) {
+             ret = create_user_suspend_blocker(file, arg, _IOC_SIZE(cmd));
+             goto done;
+     }

Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!

Quoted 4 lines

This is not uncommon. _IOC encodes the size of the argument, and if this is not a fixed size, then the raw ioctl number change based on the size passed in. Look at input.h is you want other examples of this.

Ok, I found few examples in code:

pavel@amd:/data/l/linux$ grep -ri IOCSIZE_MASK .
./arch/alpha/include/asm/ioctl.h:#define IOCSIZE_MASK	(_IOC_SIZEMASK
<< _IOC_SIZESHIFT)
./arch/mips/include/asm/ioctl.h:#define IOCSIZE_MASK	(_IOC_SIZEMASK
<< _IOC_SIZESHIFT)
./arch/sparc/include/asm/ioctl.h:#define IOCSIZE_MASK
(_IOC_XSIZEMASK << _IOC_SIZESHIFT)
./drivers/input/joydev.c:		if ((cmd & ~IOCSIZE_MASK) ==
JSIOCGNAME(0)) {
./drivers/message/fusion/mptctl.c:	if ((cmd & ~IOCSIZE_MASK) ==
(MPTIOCINFO & ~IOCSIZE_MASK)) {
./drivers/message/fusion/mptctl.c:	else if ((cmd & ~IOCSIZE_MASK)
== (HP_GETHOSTINFO & ~IOCSIZE_MASK))
./drivers/mtd/mtdchar.c:	size = (cmd & IOCSIZE_MASK) >>
IOCSIZE_SHIFT;
./drivers/pcmcia/pcmcia_ioctl.c:    size = (cmd & IOCSIZE_MASK) >>
IOCSIZE_SHIFT;
./include/asm-generic/ioctl.h:#define IOCSIZE_MASK	(_IOC_SIZEMASK
<< _IOC_SIZESHIFT)

I still do not like introducing 16000 ioctls, and I'm not sure how our ioctl compatibility layer playes with this.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#37 lore raw
In reply to Arve Hjønnevåg
Quoted 4 lines · Arve Hjønnevåg

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.

My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?

IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.

The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.

If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.

What am I missing?

Kevin

#38 lore raw

2009/5/6 Kevin Hilman <[email protected]>:

Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

Quoted 7 lines

Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.

My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?

We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.

Quoted 4 lines

IOW, why not use CPUidle + PM QoS to achieve the same goal?  It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem.  I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.

suspend blockers have no impact on this.

Quoted 4 lines

The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle.  But with tools like powertop, it's pretty easy to find these problems and fix them.

Tools allow you to find apps that waste power, but they do not fix them.

Quoted 5 lines

If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.

What am I missing?

Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.

Signature · 1 line
Arve Hjønnevåg
#39 lore raw
Quoted 16 lines · Arve Hjønnevåg

2009/5/6 Kevin Hilman <[email protected]>:

Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

Quoted 7 lines

Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.

My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?

Quoted 7 lines

We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.

Yes CPUIDLE and pmqos are more "cooperative" power management, where suspend is a preemptive form of PM. I get a little itchy when the preemptive PM is made automatic from the kernel level.

BTW Thanks. I feel like I'm understanding your PM design a bit better now.

--mgross

Quoted 33 lines
Quoted 5 lines

IOW, why not use CPUidle + PM QoS to achieve the same goal?  It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem.  I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.

suspend blockers have no impact on this.

Quoted 4 lines

The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle.  But with tools like powertop, it's pretty easy to find these problems and fix them.

Tools allow you to find apps that waste power, but they do not fix them.

Quoted 5 lines

If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.

What am I missing?

Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.

Signature · 5 lines
Arve Hjønnevåg
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#40 lore raw
In reply to Arve Hjønnevåg
Quoted 41 lines · Arve Hjønnevåg

2009/5/6 Kevin Hilman <[email protected]>:

Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

Quoted 7 lines

Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.

My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?

We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.

Quoted 4 lines

IOW, why not use CPUidle + PM QoS to achieve the same goal?  It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem.  I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.

suspend blockers have no impact on this.

Quoted 4 lines

The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle.  But with tools like powertop, it's pretty easy to find these problems and fix them.

Tools allow you to find apps that waste power, but they do not fix them.

Quoted 4 lines

If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.

Quoted 8 lines
Quoted 1 line

What am I missing?

Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.

Arve,

Thanks for the clarifications. Like Mark, I feel like I have a better grip on the motivation behind these changes.

Thanks,

Kevin

#41 lore raw
In reply to Arve Hjønnevåg
Quoted 50 lines · Arve Hj?nnev?g

2009/5/6 Kevin Hilman <[email protected]>:

Quoted 7 lines
Quoted 4 lines · Arve Hj?nnev?g

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.

Quoted 7 lines

Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.

My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?

We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.

Quoted 4 lines

IOW, why not use CPUidle + PM QoS to achieve the same goal?  It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem.  I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.

suspend blockers have no impact on this.

Quoted 4 lines

The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle.  But with tools like powertop, it's pretty easy to find these problems and fix them.

Tools allow you to find apps that waste power, but they do not fix them.

Quoted 5 lines

If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.

What am I missing?

Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html