timerfd: Protect the might cancel mechanism proper
Subsystems (2)
PATCH 1/1 timerfd: Protect the might cancel mechanism proper
The handling of the might_cancel queueing is not properly protected, so parallel operations on the file descriptor can race with each other and lead to list corruptions or use after free.
Protect the context for these operations with a seperate lock.
The wait queue lock cannot be reused for this because that would create a lock inversion scenario vs. the cancel lock. Replacing might_cancel with an atomic (atomic_t or atomic bit) does not help either because it still can race vs. the actual list operation.
--- fs/timerfd.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)
fs/timerfd.c +14 -3
@@ -40,6 +40,7 @@ struct timerfd_ctx {short unsigned settime_flags;/* to show in fdinfo */ struct rcu_head rcu;struct list_head clist; +spinlock_t cancel_lock;bool might_cancel; };
@@ -112,7 +113,7 @@ void timerfd_clock_was_set(void)rcu_read_unlock (); } -static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +static void __timerfd_remove_cancel (struct timerfd_ctx *ctx) {if (ctx->might_cancel) { ctx->might_cancel = false;
@@ -122,6 +123,13 @@ static void timerfd_remove_cancel(struct } } +static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +{ +spin_lock (&ctx->cancel_lock); +__timerfd_remove_cancel (ctx); +spin_unlock (&ctx->cancel_lock); +} +static bool timerfd_canceled (struct timerfd_ctx *ctx) {if (!ctx->might_cancel || ctx->moffs !=KTIME_MAX )
@@ -132,6 +140,7 @@ static bool timerfd_canceled(struct timestatic void timerfd_setup_cancel (struct timerfd_ctx *ctx,int flags) { +spin_lock (&ctx->cancel_lock);if ((ctx->clockid ==CLOCK_REALTIME || ctx->clockid ==CLOCK_REALTIME_ALARM ) && (flags &TFD_TIMER_ABSTIME ) && (flags &TFD_TIMER_CANCEL_ON_SET )) {
@@ -141,9 +150,10 @@ static void timerfd_setup_cancel(structlist_add_rcu (&ctx->clist, &cancel_list);spin_unlock (&cancel_lock); } - }else if (ctx->might_cancel) { -timerfd_remove_cancel (ctx); + }else { +__timerfd_remove_cancel (ctx); } +spin_unlock (&ctx->cancel_lock); }static ktime_t timerfd_get_remaining (struct timerfd_ctx *ctx)
@@ -400,6 +410,7 @@ SYSCALL_DEFINE2(timerfd_create, int, cloreturn -ENOMEM ;init_waitqueue_head (&ctx->wqh); +spin_lock_init (&ctx->cancel_lock); ctx->clockid = clockid;if (isalarm (ctx))
Quoted 72 lines · Thomas Gleixner
The handling of the
might_cancelqueueing is not properly protected, so parallel operations on the file descriptor can race with each other and lead to list corruptions or use after free.Protect the context for these operations with a seperate lock.
The wait queue lock cannot be reused for this because that would create a lock inversion scenario vs. the cancel lock. Replacing
might_cancelwith an atomic (atomic_tor atomic bit) does not help either because it still can race vs. the actual list operation.Reported-by Dmitry Vyukov <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>--- fs/timerfd.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)fs/timerfd.c +13
-3@@ -40,6 +40,7 @@ struct timerfd_ctx {short unsigned settime_flags;/* to show in fdinfo */ struct rcu_head rcu;struct list_head clist; +spinlock_t cancel_lock;bool might_cancel; };@@ -112,7 +113,7 @@ void timerfd_clock_was_set(void)rcu_read_unlock (); } -static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +static void __timerfd_remove_cancel (struct timerfd_ctx *ctx) {if (ctx->might_cancel) { ctx->might_cancel = false;@@ -122,6 +123,13 @@ static void timerfd_remove_cancel(struct } } +static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +{ +spin_lock (&ctx->cancel_lock); +__timerfd_remove_cancel (ctx); +spin_unlock (&ctx->cancel_lock); +} +static bool timerfd_canceled (struct timerfd_ctx *ctx) {if (!ctx->might_cancel || ctx->moffs !=KTIME_MAX )@@ -132,6 +140,7 @@ static bool timerfd_canceled(struct timestatic void timerfd_setup_cancel (struct timerfd_ctx *ctx,int flags) { +spin_lock (&ctx->cancel_lock);if ((ctx->clockid ==CLOCK_REALTIME || ctx->clockid ==CLOCK_REALTIME_ALARM ) && (flags &TFD_TIMER_ABSTIME ) && (flags &TFD_TIMER_CANCEL_ON_SET )) {@@ -141,9 +150,10 @@ static void timerfd_setup_cancel(structlist_add_rcu (&ctx->clist, &cancel_list);spin_unlock (&cancel_lock); } - }else if (ctx->might_cancel) { -timerfd_remove_cancel (ctx); + }else { +__timerfd_remove_cancel (ctx); } +spin_unlock (&ctx->cancel_lock); }static ktime_t timerfd_get_remaining (struct timerfd_ctx *ctx)
fs/timerfd.c SYSCALL_DEFINE2(timerfd_create, int, clo · line 416
Quoted 7 lines
fs/timerfd.c +1
-0@@ -400,6 +410,7 @@ SYSCALL_DEFINE2(timerfd_create, int, cloreturn -ENOMEM ;init_waitqueue_head (&ctx->wqh); +spin_lock_init (&ctx->cancel_lock); ctx->clockid = clockid;if (isalarm (ctx))
Can't we still end up with an inconsistently setup timer? do_timerfd_settime executes timerfd_setup_cancel and timerfd_setup as two separate non-atomic actions. So if there are 2 concurrent timerfd_settime calls, one that needs cancel and another that does not need cancel, can't we end up with inconsistent setup? E.g. setup timer that needs cancel, but it won't be in cancel_list. Or vice versa.
Quoted 7 lines · Dmitry Vyukov
Can't we still end up with an inconsistently setup timer?
do_timerfd_settimeexecutestimerfd_setup_cancelandtimerfd_setupas two separate non-atomic actions. So if there are 2 concurrenttimerfd_settimecalls, one that needs cancel and another that does not need cancel, can't we end up with inconsistent setup? E.g. setup timer that needs cancel, but it won't be incancel_list. Or vice versa.
Do we really care? If an application arms the timer with cancel in one thread and the same timer without cancel in another thread, then it's probably completely irrelevant whether the state pair timeout/cancel is correct or not. That's clearly an application bug and I don't want to add more locking just to make something which is broken by definition pseudo 'atomic'.
Thanks,
tglx
Quoted 9 lines · Thomas Gleixner
Quoted 7 lines · Dmitry Vyukov
Can't we still end up with an inconsistently setup timer?
do_timerfd_settimeexecutestimerfd_setup_cancelandtimerfd_setupas two separate non-atomic actions. So if there are 2 concurrenttimerfd_settimecalls, one that needs cancel and another that does not need cancel, can't we end up with inconsistent setup? E.g. setup timer that needs cancel, but it won't be incancel_list. Or vice versa.
Quoted 6 lines
Do we really care? If an application arms the timer with cancel in one thread and the same timer without cancel in another thread, then it's probably completely irrelevant whether the state pair timeout/cancel is correct or not. That's clearly an application bug and I don't want to add more locking just to make something which is broken by definition pseudo 'atomic'.
I agree that the program is bogus, and don't have to ensure any sane behavior for it. But I am concerned about potential kernel corruptions due to this. For example, maybe kernel code will decide to not remove such timer from the cancel list on destruction because based on clockid/flags it should not be in the cancel list, but the timer is actually there and we will end up with a leak or a dangling pointer. I did not check that this actually happens, such inconsistent state just looks like a red flag for me.
Dmitry,
Quoted 17 lines · Dmitry Vyukov
Quoted 9 lines · Thomas Gleixner
Quoted 7 lines · Dmitry Vyukov
Can't we still end up with an inconsistently setup timer?
do_timerfd_settimeexecutestimerfd_setup_cancelandtimerfd_setupas two separate non-atomic actions. So if there are 2 concurrenttimerfd_settimecalls, one that needs cancel and another that does not need cancel, can't we end up with inconsistent setup? E.g. setup timer that needs cancel, but it won't be incancel_list. Or vice versa.Quoted 6 lines
Do we really care? If an application arms the timer with cancel in one thread and the same timer without cancel in another thread, then it's probably completely irrelevant whether the state pair timeout/cancel is correct or not. That's clearly an application bug and I don't want to add more locking just to make something which is broken by definition pseudo 'atomic'.
Quoted 8 lines
I agree that the program is bogus, and don't have to ensure any sane behavior for it. But I am concerned about potential kernel corruptions due to this. For example, maybe kernel code will decide to not remove such timer from the cancel list on destruction because based on clockid/flags it should not be in the cancel list, but the timer is actually there and we will end up with a leak or a dangling pointer. I did not check that this actually happens, such inconsistent state just looks like a red flag for me.
That can't happen.
ctx->might_cancel and ctx->clist are always in sync with the new lock and that's the only interesting thing. On destruction we don't look at clockid or such, we only care about might_cancel.
What is not guaranteed to be in sync is the timer expiry time and the cancel stuff, if two threads operate on the same timerfd in parallel. That's what I do not care about at all.
Thanks,
tglx
Dmitry Vyukov
Acked-byQuoted 32 lines · Thomas Gleixner
Dmitry,
Quoted 17 lines · Dmitry Vyukov
Quoted 9 lines · Thomas Gleixner
Quoted 7 lines · Dmitry Vyukov
Can't we still end up with an inconsistently setup timer?
do_timerfd_settimeexecutestimerfd_setup_cancelandtimerfd_setupas two separate non-atomic actions. So if there are 2 concurrenttimerfd_settimecalls, one that needs cancel and another that does not need cancel, can't we end up with inconsistent setup? E.g. setup timer that needs cancel, but it won't be incancel_list. Or vice versa.Quoted 6 lines
Do we really care? If an application arms the timer with cancel in one thread and the same timer without cancel in another thread, then it's probably completely irrelevant whether the state pair timeout/cancel is correct or not. That's clearly an application bug and I don't want to add more locking just to make something which is broken by definition pseudo 'atomic'.
Quoted 8 lines
I agree that the program is bogus, and don't have to ensure any sane behavior for it. But I am concerned about potential kernel corruptions due to this. For example, maybe kernel code will decide to not remove such timer from the cancel list on destruction because based on clockid/flags it should not be in the cancel list, but the timer is actually there and we will end up with a leak or a dangling pointer. I did not check that this actually happens, such inconsistent state just looks like a red flag for me.
That can't happen.
Quoted 7 lines
ctx->might_cancelandctx->clistare always in sync with the new lock and that's the only interesting thing. On destruction we don't look at clockid or such, we only care aboutmight_cancel.What is not guaranteed to be in sync is the timer expiry time and the cancel stuff, if two threads operate on the same timerfd in parallel. That's what I do not care about at all.
Ack. Thanks for looking at it bearing with me. Then:
Quoted 10 lines · Dmitry Vyukov
Quoted 7 lines · Thomas Gleixner
ctx->might_cancelandctx->clistare always in sync with the new lock and that's the only interesting thing. On destruction we don't look at clockid or such, we only care aboutmight_cancel.What is not guaranteed to be in sync is the timer expiry time and the cancel stuff, if two threads operate on the same timerfd in parallel. That's what I do not care about at all.
Ack. Thanks for looking at it bearing with me. Then:
Thanks for asking the questions. It's always good if we need to think it over again.
Thanks,
tglx
tip-bot for Thomas Gleixner
merge bottimerfd: Protect the might cancel mechanism proper
Commit-ID: 1e38da300e1e395a15048b0af1e5305bd91402f6 Gitweb: http://git.kernel.org/tip/1e38da300e1e395a15048b0af1e5305bd91402f6 Author: Thomas Gleixner <[email protected]> AuthorDate: Tue, 31 Jan 2017 15:24:03 +0100 Committer: Thomas Gleixner <[email protected]> CommitDate: Fri, 10 Feb 2017 11:15:09 +0100
timerfd: Protect the might cancel mechanism proper
The handling of the might_cancel queueing is not properly protected, so parallel operations on the file descriptor can race with each other and lead to list corruptions or use after free.
Protect the context for these operations with a seperate lock.
The wait queue lock cannot be reused for this because that would create a lock inversion scenario vs. the cancel lock. Replacing might_cancel with an atomic (atomic_t or atomic bit) does not help either because it still can race vs. the actual list operation.
--- fs/timerfd.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)
fs/timerfd.c +14 -3
@@ -40,6 +40,7 @@ struct timerfd_ctx {short unsigned settime_flags;/* to show in fdinfo */ struct rcu_head rcu;struct list_head clist; +spinlock_t cancel_lock;bool might_cancel; };
@@ -112,7 +113,7 @@ void timerfd_clock_was_set(void)rcu_read_unlock (); } -static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +static void __timerfd_remove_cancel (struct timerfd_ctx *ctx) {if (ctx->might_cancel) { ctx->might_cancel = false;
@@ -122,6 +123,13 @@ static void timerfd_remove_cancel(struct timerfd_ctx *ctx) } } +static void timerfd_remove_cancel (struct timerfd_ctx *ctx) +{ +spin_lock (&ctx->cancel_lock); +__timerfd_remove_cancel (ctx); +spin_unlock (&ctx->cancel_lock); +} +static bool timerfd_canceled (struct timerfd_ctx *ctx) {if (!ctx->might_cancel || ctx->moffs !=KTIME_MAX )
@@ -132,6 +140,7 @@ static bool timerfd_canceled(struct timerfd_ctx *ctx)static void timerfd_setup_cancel (struct timerfd_ctx *ctx,int flags) { +spin_lock (&ctx->cancel_lock);if ((ctx->clockid ==CLOCK_REALTIME || ctx->clockid ==CLOCK_REALTIME_ALARM ) && (flags &TFD_TIMER_ABSTIME ) && (flags &TFD_TIMER_CANCEL_ON_SET )) {
@@ -141,9 +150,10 @@ static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)list_add_rcu (&ctx->clist, &cancel_list);spin_unlock (&cancel_lock); } - }else if (ctx->might_cancel) { -timerfd_remove_cancel (ctx); + }else { +__timerfd_remove_cancel (ctx); } +spin_unlock (&ctx->cancel_lock); }static ktime_t timerfd_get_remaining (struct timerfd_ctx *ctx)
@@ -400,6 +410,7 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)return -ENOMEM ;init_waitqueue_head (&ctx->wqh); +spin_lock_init (&ctx->cancel_lock); ctx->clockid = clockid;if (isalarm (ctx))