timer: Document TIMER_PINNED
PATCH v3 1/1 timer: Document TIMER_PINNED
The flag hints the user that the pinned timers will always be run on a static CPU (because that should be what "pinned" means...) but that's not the truth, at least with current implementation.
For example, currently if we setup a pinned timer but later on we call mod_timer() upon the pinned timer, the mod_timer() will still try to run the timer on the current processor and migrate the timer if necessary.
Document it a bit with the definition of TIMER_PINNED so that all future users will use it correctly.
--- include/linux/timer.h | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-)
include/linux/timer.h +19 -8
@@ -36,19 +36,30 @@ struct timer_list {#define __TIMER_LOCKDEP_MAP_INITIALIZER (_kn)#endif -/* -* A deferrable timer will work normally when the system is busy, but -* will not cause a CPU to come out of idle just to service it; instead, -* the timer will be serviced when the CPU eventually wakes up with a -* subsequent non-deferrable timer. +/** +* @TIMER_DEFERRABLE: A deferrable timer will work normally when the +* system is busy, but will not cause a CPU to come out of idle just +* to service it; instead, the timer will be serviced when the CPU +* eventually wakes up with a subsequent non-deferrable timer. * -* An irqsafe timer is executed with IRQ disabled and it's safe to wait for -* the completion of the running instance from IRQ handlers, for example, -* by calling del_timer_sync(). +* @TIMER_IRQSAFE: An irqsafe timer is executed with IRQ disabled and +* it's safe to wait for the completion of the running instance from +* IRQ handlers, for example, by calling del_timer_sync(). * * Note: The irq disabled callback execution is a special case for * workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! +* +* @TIMER_PINNED: A pinned timer will not be affected by any timer +* placement heuristics (like, NOHZ) and will always be run on the CPU +* on which the timer was enqueued. +* +* Note: Because enqueuing of timers can migrate the timer from one +* CPU to another, pinned timers are not guaranteed to stay on the +* initialy selected CPU. They move to the CPU on which the enqueue +* function is invoked via mod_timer() or add_timer(). If the timer +* should be placed on a particular CPU, then add_timer_on() has to be +* used. */ #define TIMER_CPUMASK 0x0003FFFF#define TIMER_MIGRATING 0x00040000
Signature · 1 line
2.21.0
tip-bot for Peter Xu
merge bottimer: Document TIMER_PINNED
Commit-ID: 042c79988172ec394d62ba762f09b77e14ecc5b6 Gitweb: https://git.kernel.org/tip/042c79988172ec394d62ba762f09b77e14ecc5b6 Author: Peter Xu <[email protected]> AuthorDate: Fri, 28 Jun 2019 18:59:42 +0800 Committer: Thomas Gleixner <[email protected]> CommitDate: Wed, 3 Jul 2019 22:11:58 +0200
timer: Document TIMER_PINNED
The flag hints the user that the pinned timers will always be run on a static CPU (because that should be what "pinned" means...) but that's not the truth, at least with the current implementation.
For example, currently if a pinned timer is set up but later mod_timer() upon the pinned timer is invoked, mod_timer() will still try to queue the timer on the current processor and migrate the timer if necessary.
Document it a bit with the definition of TIMER_PINNED so that all future users will use it correctly.
--- include/linux/timer.h | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-)
include/linux/timer.h +19 -8
@@ -36,19 +36,30 @@ struct timer_list {#define __TIMER_LOCKDEP_MAP_INITIALIZER (_kn)#endif -/* -* A deferrable timer will work normally when the system is busy, but -* will not cause a CPU to come out of idle just to service it; instead, -* the timer will be serviced when the CPU eventually wakes up with a -* subsequent non-deferrable timer. +/** +* @TIMER_DEFERRABLE: A deferrable timer will work normally when the +* system is busy, but will not cause a CPU to come out of idle just +* to service it; instead, the timer will be serviced when the CPU +* eventually wakes up with a subsequent non-deferrable timer. * -* An irqsafe timer is executed with IRQ disabled and it's safe to wait for -* the completion of the running instance from IRQ handlers, for example, -* by calling del_timer_sync(). +* @TIMER_IRQSAFE: An irqsafe timer is executed with IRQ disabled and +* it's safe to wait for the completion of the running instance from +* IRQ handlers, for example, by calling del_timer_sync(). * * Note: The irq disabled callback execution is a special case for * workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! +* +* @TIMER_PINNED: A pinned timer will not be affected by any timer +* placement heuristics (like, NOHZ) and will always expire on the CPU +* on which the timer was enqueued. +* +* Note: Because enqueuing of timers can migrate the timer from one +* CPU to another, pinned timers are not guaranteed to stay on the +* initialy selected CPU. They move to the CPU on which the enqueue +* function is invoked via mod_timer() or add_timer(). If the timer +* should be placed on a particular CPU, then add_timer_on() has to be +* used. */ #define TIMER_CPUMASK 0x0003FFFF#define TIMER_MIGRATING 0x00040000
tip-bot for Peter Xu
merge bottimer: Document TIMER_PINNED
Commit-ID: 876d00da42ecd4e985e58faa6239f7ee7e01a8b1 Gitweb: https://git.kernel.org/tip/876d00da42ecd4e985e58faa6239f7ee7e01a8b1 Author: Peter Xu <[email protected]> AuthorDate: Fri, 28 Jun 2019 18:59:42 +0800 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 6 Jul 2019 09:57:36 +0200
timer: Document TIMER_PINNED
The flag hints the user that the pinned timers will always be run on a static CPU (because that should be what "pinned" means...) but that's not the truth, at least with the current implementation.
For example, currently if a pinned timer is set up but later mod_timer() upon the pinned timer is invoked, mod_timer() will still try to queue the timer on the current processor and migrate the timer if necessary.
Document it a bit with the definition of TIMER_PINNED so that all future users will use it correctly.
--- include/linux/timer.h | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-)
include/linux/timer.h +19 -8
@@ -36,19 +36,30 @@ struct timer_list {#define __TIMER_LOCKDEP_MAP_INITIALIZER (_kn)#endif -/* -* A deferrable timer will work normally when the system is busy, but -* will not cause a CPU to come out of idle just to service it; instead, -* the timer will be serviced when the CPU eventually wakes up with a -* subsequent non-deferrable timer. +/** +* @TIMER_DEFERRABLE: A deferrable timer will work normally when the +* system is busy, but will not cause a CPU to come out of idle just +* to service it; instead, the timer will be serviced when the CPU +* eventually wakes up with a subsequent non-deferrable timer. * -* An irqsafe timer is executed with IRQ disabled and it's safe to wait for -* the completion of the running instance from IRQ handlers, for example, -* by calling del_timer_sync(). +* @TIMER_IRQSAFE: An irqsafe timer is executed with IRQ disabled and +* it's safe to wait for the completion of the running instance from +* IRQ handlers, for example, by calling del_timer_sync(). * * Note: The irq disabled callback execution is a special case for * workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! +* +* @TIMER_PINNED: A pinned timer will not be affected by any timer +* placement heuristics (like, NOHZ) and will always expire on the CPU +* on which the timer was enqueued. +* +* Note: Because enqueuing of timers can migrate the timer from one +* CPU to another, pinned timers are not guaranteed to stay on the +* initialy selected CPU. They move to the CPU on which the enqueue +* function is invoked via mod_timer() or add_timer(). If the timer +* should be placed on a particular CPU, then add_timer_on() has to be +* used. */ #define TIMER_CPUMASK 0x0003FFFF#define TIMER_MIGRATING 0x00040000
tip-bot for Peter Xu
merge bottimer: Document TIMER_PINNED
Commit-ID: 28ef2db8866495150e4260773fead8313f1a5625 Gitweb: https://git.kernel.org/tip/28ef2db8866495150e4260773fead8313f1a5625 Author: Peter Xu <[email protected]> AuthorDate: Fri, 28 Jun 2019 18:59:42 +0800 Committer: Thomas Gleixner <[email protected]> CommitDate: Sun, 7 Jul 2019 11:50:03 +0200
timer: Document TIMER_PINNED
The flag hints the user that the pinned timers will always be run on a static CPU (because that should be what "pinned" means...) but that's not the truth, at least with the current implementation.
For example, currently if a pinned timer is set up but later mod_timer() upon the pinned timer is invoked, mod_timer() will still try to queue the timer on the current processor and migrate the timer if necessary.
Document it a bit with the definition of TIMER_PINNED so that all future users will use it correctly.
--- include/linux/timer.h | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-)
include/linux/timer.h +19 -8
@@ -36,19 +36,30 @@ struct timer_list {#define __TIMER_LOCKDEP_MAP_INITIALIZER (_kn)#endif -/* -* A deferrable timer will work normally when the system is busy, but -* will not cause a CPU to come out of idle just to service it; instead, -* the timer will be serviced when the CPU eventually wakes up with a -* subsequent non-deferrable timer. +/** +* @TIMER_DEFERRABLE: A deferrable timer will work normally when the +* system is busy, but will not cause a CPU to come out of idle just +* to service it; instead, the timer will be serviced when the CPU +* eventually wakes up with a subsequent non-deferrable timer. * -* An irqsafe timer is executed with IRQ disabled and it's safe to wait for -* the completion of the running instance from IRQ handlers, for example, -* by calling del_timer_sync(). +* @TIMER_IRQSAFE: An irqsafe timer is executed with IRQ disabled and +* it's safe to wait for the completion of the running instance from +* IRQ handlers, for example, by calling del_timer_sync(). * * Note: The irq disabled callback execution is a special case for * workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! +* +* @TIMER_PINNED: A pinned timer will not be affected by any timer +* placement heuristics (like, NOHZ) and will always expire on the CPU +* on which the timer was enqueued. +* +* Note: Because enqueuing of timers can migrate the timer from one +* CPU to another, pinned timers are not guaranteed to stay on the +* initialy selected CPU. They move to the CPU on which the enqueue +* function is invoked via mod_timer() or add_timer(). If the timer +* should be placed on a particular CPU, then add_timer_on() has to be +* used. */ #define TIMER_CPUMASK 0x0003FFFF#define TIMER_MIGRATING 0x00040000