lib/refcount: Document interaction with PID_MAX_LIMIT
PATCH 1/1 lib/refcount: Document interaction with PID_MAX_LIMIT
Document the circumstances under which refcount_t's saturation mechanism works deterministically.
--- include/linux/refcount.h | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-)
include/linux/refcount.h +14 -5
@@ -38,11 +38,20 @@* atomic operations, then the count will continue to edge closer to 0. If it * reaches a value of 1 before /any/ of the threads reset it to the saturated * value, then a concurrent refcount_dec_and_test() may erroneously free the -* underlying object. Given the precise timing details involved with the -* round-robin scheduling of each thread manipulating the refcount and the need -* to hit the race multiple times in succession, there doesn't appear to be a -* practical avenue of attack even if using refcount_add() operations with -* larger increments. +* underlying object. +* Linux limits the maximum number of tasks to PID_MAX_LIMIT, which is currently +* 0x400000 (and can't easily be raised in the future beyond FUTEX_TID_MASK). +* With the current PID limit, if no batched refcounting operations are used and +* the attacker can't repeatedly trigger kernel oopses in the middle of refcount +* operations, this makes it impossible for a saturated refcount to leave the +* saturation range, even if it is possible for multiple uses of the same +* refcount to nest in the context of a single task. +* If hundreds of references are added/removed with a single refcounting +* operation, it may potentially be possible to leave the saturation range; but +* given the precise timing details involved with the round-robin scheduling of +* each thread manipulating the refcount and the need to hit the race multiple +* times in succession, there doesn't appear to be a practical avenue of attack +* even if using refcount_add() operations with larger increments. * * Memory ordering * ===============
base-commit: 98d54f81e36ba3bf92172791eba5ca5bd813989b
Signature · 1 line
2.25.0.265.gbab2e86ba0-goog
Quoted 4 lines · Jann Horn
Document the circumstances under which refcount_t's saturation mechanism works deterministically.
Signed-off-by Jann Horn <[email protected]>
With one note below...
Quoted 10 lines
--- include/linux/refcount.h | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-)include/linux/refcount.h +0
-0@@ -38,11 +38,20 @@* atomic operations, then the count will continue to edge closer to 0. If it
include/linux/refcount.h line 43
Quoted 10 lines
include/linux/refcount.h +3
-5* reaches a value of 1 before /any/ of the threads reset it to the saturated * value, then a concurrent refcount_dec_and_test() may erroneously free the -* underlying object. Given the precise timing details involved with the -* round-robin scheduling of each thread manipulating the refcount and the need -* to hit the race multiple times in succession, there doesn't appear to be a -* practical avenue of attack even if using refcount_add() operations with -* larger increments. +* underlying object. +* Linux limits the maximum number of tasks to PID_MAX_LIMIT, which is currently +* 0x400000 (and can't easily be raised in the future beyond FUTEX_TID_MASK).
Maybe just to clarify and make readers not have to go search the source:
"... beyond FUTEX_TID_MASK, which is UAPI defined as 0x3fffffff)."
and is it worth showing the math on this, just to have it clearly stated?
-Kees
Quoted 19 lines
include/linux/refcount.h +11
-0+* With the current PID limit, if no batched refcounting operations are used and +* the attacker can't repeatedly trigger kernel oopses in the middle of refcount +* operations, this makes it impossible for a saturated refcount to leave the +* saturation range, even if it is possible for multiple uses of the same +* refcount to nest in the context of a single task. +* If hundreds of references are added/removed with a single refcounting +* operation, it may potentially be possible to leave the saturation range; but +* given the precise timing details involved with the round-robin scheduling of +* each thread manipulating the refcount and the need to hit the race multiple +* times in succession, there doesn't appear to be a practical avenue of attack +* even if using refcount_add() operations with larger increments. * * Memory ordering * =============== base-commit:
98d54f81e36ba3bf92172791eba5ca5bd813989bSignature · 1 line
2.25.0.265.gbab2e86ba0-goog
Signature · 1 line
Kees Cook
Quoted 33 lines · Kees Cook
Quoted 4 lines · Jann Horn
Document the circumstances under which refcount_t's saturation mechanism works deterministically.
Signed-off-by Jann Horn <[email protected]>Acked-by Kees Cook <[email protected]>With one note below...
Quoted 10 lines
--- include/linux/refcount.h | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-)include/linux/refcount.h +0
-0@@ -38,11 +38,20 @@* atomic operations, then the count will continue to edge closer to 0. If it include/linux/refcount.h line 43
Quoted 10 lines
include/linux/refcount.h +3
-5* reaches a value of 1 before /any/ of the threads reset it to the saturated * value, then a concurrent refcount_dec_and_test() may erroneously free the -* underlying object. Given the precise timing details involved with the -* round-robin scheduling of each thread manipulating the refcount and the need -* to hit the race multiple times in succession, there doesn't appear to be a -* practical avenue of attack even if using refcount_add() operations with -* larger increments. +* underlying object. +* Linux limits the maximum number of tasks to PID_MAX_LIMIT, which is currently +* 0x400000 (and can't easily be raised in the future beyond FUTEX_TID_MASK). Maybe just to clarify and make readers not have to go search the source:
Quoted 1 line
"... beyond FUTEX_TID_MASK, which is UAPI defined as 0x3fffffff)."
The value of that thing has changed three times in git history, and there is a comment in threads.h that refers to it as being 0x1fffffff; so I'm a bit hesitant to copy that around further.
Quoted 2 lines
and is it worth showing the math on this, just to have it clearly stated?
Hm, I suppose... I'll send a v2.
Quoted 13 lines
-Kees
Quoted 11 lines
include/linux/refcount.h +11
-0+* With the current PID limit, if no batched refcounting operations are used and +* the attacker can't repeatedly trigger kernel oopses in the middle of refcount +* operations, this makes it impossible for a saturated refcount to leave the +* saturation range, even if it is possible for multiple uses of the same +* refcount to nest in the context of a single task. +* If hundreds of references are added/removed with a single refcounting +* operation, it may potentially be possible to leave the saturation range; but +* given the precise timing details involved with the round-robin scheduling of +* each thread manipulating the refcount and the need to hit the race multiple +* times in succession, there doesn't appear to be a practical avenue of attack +* even if using refcount_add() operations with larger increments.