Revert "binder_alloc: add missing mmap_lock calls when using the VMA"
Subsystems (2)
Carlos Llamas
maintainerRFC PATCH 1/3 Revert "binder_alloc: add missing mmap_lock calls when using the VMA"
This reverts commit 44e602b4e52f70f04620bbbf4fe46ecb40170bde.
This caused a performance regression particularly when pages are getting reclaimed. We don't need to acquire the mmap_lock to determine when the binder buffer has been fully initialized. A subsequent patch will bring back the lockless approach for this.
[cmllamas: resolved trivial conflicts with renaming of alloc->mm]
--- drivers/android/binder_alloc.c | 31 ++++++++++--------------------- 1 file changed, 10 insertions(+), 21 deletions(-)
drivers/android/binder_alloc.c +10 -21
@@ -380,15 +380,12 @@ static struct binder_buffer *binder_alloc_new_buf_locked(size_t size, data_offsets_size;int ret; -mmap_read_lock (alloc->mm);if (!binder_alloc_get_vma (alloc)) { -mmap_read_unlock (alloc->mm);binder_alloc_debug (BINDER_DEBUG_USER_ERROR ,"%d: binder_alloc_buf, no vma\n" , alloc->pid);return ERR_PTR (-ESRCH ); } -mmap_read_unlock (alloc->mm); data_offsets_size =ALIGN (data_size,sizeof (void *)) +ALIGN (offsets_size,sizeof (void *));
@@ -916,25 +913,17 @@ void binder_alloc_print_pages(struct seq_file *m,* Make sure the binder_alloc is fully initialized, otherwise we might * read inconsistent state. */ - -mmap_read_lock (alloc->mm); -if (binder_alloc_get_vma (alloc) ==NULL ) { -mmap_read_unlock (alloc->mm); - goto uninitialized; - } - -mmap_read_unlock (alloc->mm); -for (i =0 ; i < alloc->buffer_size /PAGE_SIZE ; i++) { - page = &alloc->pages[i]; -if (!page->page_ptr) - free++; -else if (list_empty (&page->lru)) - active++; -else - lru++; +if (binder_alloc_get_vma (alloc) !=NULL ) { +for (i =0 ; i < alloc->buffer_size /PAGE_SIZE ; i++) { + page = &alloc->pages[i]; +if (!page->page_ptr) + free++; +else if (list_empty (&page->lru)) + active++; +else + lru++; + } } - -uninitialized:mutex_unlock (&alloc->mutex);seq_printf (m," pages: %d:%d:%d\n" , active, lru, free);seq_printf (m," pages high watermark: %zu\n" , alloc->pages_high);
Signature · 1 line
2.40.0.634.g4ca3ef3211-goog
Carlos Llamas
maintainerRFC PATCH 2/3 Revert "android: binder: stop saving a pointer to the VMA"
This reverts commit a43cfc87caaf46710c8027a8c23b8a55f1078f19.
This patch fixed an issue reported by syzkaller in [1]. However, this turned out to be only a band-aid in binder. The root cause, as bisected by syzkaller, was fixed by commit 5789151e48ac ("mm/mmap: undo ->mmap() when mas_preallocate() fails"). We no longer need the patch for binder.
Reverting such patch allows us to have a lockless access to alloc->vma in specific cases where the mmap_lock is not required. This approach avoids the contention that caused a performance regression.
[1] https://lore.kernel.org/all/[email protected]
[cmllamas: resolved conflicts with rework of alloc->mm and removal of
binder_alloc_set_vma() also fixed comment section]
--- drivers/android/binder_alloc.c | 17 +++++++++-------- drivers/android/binder_alloc.h | 4 ++-- drivers/android/binder_alloc_selftest.c | 2 +- 3 files changed, 12 insertions(+), 11 deletions(-)
drivers/android/binder_alloc.c +9 -8
@@ -213,7 +213,7 @@ static int binder_update_page_range(struct binder_alloc *alloc, int allocate,if (mm) {mmap_read_lock (mm); - vma =vma_lookup (mm, alloc->vma_addr); + vma = alloc->vma; }if (!vma && need_mm) {
@@ -314,9 +314,11 @@ static inline struct vm_area_struct *binder_alloc_get_vma( {struct vm_area_struct *vma =NULL ; -if (alloc->vma_addr) - vma =vma_lookup (alloc->mm, alloc->vma_addr); - +if (alloc->vma) { +/* Look at description in binder_alloc_set_vma */ +smp_rmb (); + vma = alloc->vma; + }return vma; }
@@ -775,7 +777,7 @@ int binder_alloc_mmap_handler(struct binder_alloc *alloc, buffer->free =1 ;binder_insert_free_buffer (alloc, buffer); alloc->free_async_space = alloc->buffer_size /2 ; - alloc->vma_addr = vma->vm_start; + alloc->vma = vma;return 0 ;
@@ -805,8 +807,7 @@ void binder_alloc_deferred_release(struct binder_alloc *alloc) buffers =0 ;mutex_lock (&alloc->mutex); -BUG_ON (alloc->vma_addr && -vma_lookup (alloc->mm, alloc->vma_addr)); +BUG_ON (alloc->vma);while ((n =rb_first (&alloc->allocated_buffers))) { buffer = rb_entry(n, struct binder_buffer, rb_node);
@@ -958,7 +959,7 @@ int binder_alloc_get_allocated_count(struct binder_alloc *alloc)*/ void binder_alloc_vma_close (struct binder_alloc *alloc) { - alloc->vma_addr =0 ; + alloc->vma =0 ; }/**
drivers/android/binder_alloc.h +2 -2
@@ -75,7 +75,7 @@ struct binder_lru_page {/** * struct binder_alloc - per-binder proc state for binder allocator * @mutex: protects binder_alloc fields -* @vma_addr: vm_area_struct->vm_start passed to mmap_handler +* @vma: vm_area_struct passed to mmap_handler * (invariant after mmap) * @mm: copy of task->mm (invariant after open) * @buffer: base of per-proc address space mapped via mmap
@@ -99,7 +99,7 @@ struct binder_lru_page {*/ struct binder_alloc {struct mutex mutex; -unsigned long vma_addr; +struct vm_area_struct *vma;struct mm_struct *mm;void __user *buffer;struct list_head buffers;
drivers/android/binder_alloc_selftest.c +1 -1
@@ -287,7 +287,7 @@ void binder_selftest_alloc(struct binder_alloc *alloc)if (!binder_selftest_run)return ;mutex_lock (&binder_selftest_lock); -if (!binder_selftest_run || !alloc->vma_addr) +if (!binder_selftest_run || !alloc->vma) goto done;pr_info ("STARTED\n" );binder_selftest_alloc_offset (alloc, end_offset,0 );
Signature · 1 line
2.40.0.634.g4ca3ef3211-goog
Re: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Cc linux-mm
Quoted 9 lines · Carlos Llamas
This reverts commit
a43cfc87caaf46710c8027a8c23b8a55f1078f19.This patch fixed an issue reported by syzkaller in [1]. However, this turned out to be only a band-aid in binder. The root cause, as bisected by syzkaller, was fixed by commit
5789151e48ac("mm/mmap: undo ->mmap() whenmas_preallocate()fails"). We no longer need the patch for binder.Reverting such patch allows us to have a lockless access to
alloc->vmain specific cases where themmap_lockis not required.
Can you elaborate on the situation where recording a VMA pointer and later accessing it outside the mmap_lock is okay?
Quoted 111 lines
This approach
avoids the contention that caused a performance regression.[1] https://lore.kernel.org/all/[email protected]
[cmllamas: resolved conflicts with rework of
alloc->mmand removal of
binder_alloc_set_vma()also fixed comment section]Cc Liam Howlett <[email protected]>Cc Suren Baghdasaryan <[email protected]>Signed-off-by Carlos Llamas <[email protected]>--- drivers/android/binder_alloc.c | 17 +++++++++-------- drivers/android/binder_alloc.h | 4 ++-- drivers/android/binder_alloc_selftest.c | 2 +- 3 files changed, 12 insertions(+), 11 deletions(-)drivers/android/binder_alloc.c +9
-8@@ -213,7 +213,7 @@ static int binder_update_page_range(struct binder_alloc *alloc, int allocate,if (mm) {mmap_read_lock (mm); - vma =vma_lookup (mm, alloc->vma_addr); + vma = alloc->vma; }if (!vma && need_mm) {@@ -314,9 +314,11 @@ static inline struct vm_area_struct *binder_alloc_get_vma( {struct vm_area_struct *vma =NULL ; -if (alloc->vma_addr) - vma =vma_lookup (alloc->mm, alloc->vma_addr); - +if (alloc->vma) { +/* Look at description in binder_alloc_set_vma */ +smp_rmb (); + vma = alloc->vma; + }return vma; }@@ -775,7 +777,7 @@ int binder_alloc_mmap_handler(struct binder_alloc *alloc, buffer->free =1 ;binder_insert_free_buffer (alloc, buffer); alloc->free_async_space = alloc->buffer_size /2 ; - alloc->vma_addr = vma->vm_start; + alloc->vma = vma;return 0 ;@@ -805,8 +807,7 @@ void binder_alloc_deferred_release(struct binder_alloc *alloc) buffers =0 ;mutex_lock (&alloc->mutex); -BUG_ON (alloc->vma_addr && -vma_lookup (alloc->mm, alloc->vma_addr)); +BUG_ON (alloc->vma);while ((n =rb_first (&alloc->allocated_buffers))) { buffer = rb_entry(n, struct binder_buffer, rb_node);@@ -958,7 +959,7 @@ int binder_alloc_get_allocated_count(struct binder_alloc *alloc)*/ void binder_alloc_vma_close (struct binder_alloc *alloc) { - alloc->vma_addr =0 ; + alloc->vma =0 ; }/** drivers/android/binder_alloc.h +2
-2@@ -75,7 +75,7 @@ struct binder_lru_page {/** * struct binder_alloc - per-binder proc state for binder allocator * @mutex: protects binder_alloc fields -* @vma_addr: vm_area_struct->vm_start passed to mmap_handler +* @vma: vm_area_struct passed to mmap_handler * (invariant after mmap) * @mm: copy of task->mm (invariant after open) * @buffer: base of per-proc address space mapped via mmap @@ -99,7 +99,7 @@ struct binder_lru_page {*/ struct binder_alloc {struct mutex mutex; -unsigned long vma_addr; +struct vm_area_struct *vma;struct mm_struct *mm;void __user *buffer;struct list_head buffers;drivers/android/binder_alloc_selftest.c +1
-1@@ -287,7 +287,7 @@ void binder_selftest_alloc(struct binder_alloc *alloc)if (!binder_selftest_run)return ;mutex_lock (&binder_selftest_lock); -if (!binder_selftest_run || !alloc->vma_addr) +if (!binder_selftest_run || !alloc->vma) goto done;pr_info ("STARTED\n" );binder_selftest_alloc_offset (alloc, end_offset,0 );Signature · 1 line
2.40.0.634.g4ca3ef3211-goog
Carlos Llamas
maintainerRe: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Quoted 10 lines · Liam R. Howlett
Cc linux-mm
Quoted 7 lines · Carlos Llamas
This reverts commit
a43cfc87caaf46710c8027a8c23b8a55f1078f19.This patch fixed an issue reported by syzkaller in [1]. However, this turned out to be only a band-aid in binder. The root cause, as bisected by syzkaller, was fixed by commit
5789151e48ac("mm/mmap: undo ->mmap() whenmas_preallocate()fails"). We no longer need the patch for binder.
Quoted 5 lines
Quoted 2 lines
Reverting such patch allows us to have a lockless access to
alloc->vmain specific cases where themmap_lockis not required.Can you elaborate on the situation where recording a VMA pointer and later accessing it outside the
mmap_lockis okay?
The specifics are in the third patch of this patchset but the gist of it is that during ->mmap() handler, binder will complete the initialization of the binder_alloc structure. With the last step of this process being the caching of the vma pointer. Since the ordering is protected with a barrier we can then check alloc->vma to determine if the initialization has been completed.
Since this check is part of the critical path for every single binder transaction, the performance plummeted when we started contending for the mmap_lock. In this particular case, binder doesn't actually use the vma. It only needs to know if the internal structure has been fully initialized and it is safe to use it.
FWIW, this had been the design for ~15 years. The original patch is
this: https://git.kernel.org/torvalds/c/457b9a6f09f0
Re: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Quoted 24 lines · Carlos Llamas
Quoted 10 lines · Liam R. Howlett
Cc linux-mm
Quoted 7 lines · Carlos Llamas
This reverts commit
a43cfc87caaf46710c8027a8c23b8a55f1078f19.This patch fixed an issue reported by syzkaller in [1]. However, this turned out to be only a band-aid in binder. The root cause, as bisected by syzkaller, was fixed by commit
5789151e48ac("mm/mmap: undo ->mmap() whenmas_preallocate()fails"). We no longer need the patch for binder.Quoted 5 lines
Quoted 2 lines
Reverting such patch allows us to have a lockless access to
alloc->vmain specific cases where themmap_lockis not required.Can you elaborate on the situation where recording a VMA pointer and later accessing it outside the
mmap_lockis okay?The specifics are in the third patch of this patchset but the gist of it is that during ->mmap() handler, binder will complete the initialization of the
binder_allocstructure. With the last step of this process being the caching of the vma pointer. Since the ordering is protected with a barrier we can then checkalloc->vmato determine if the initialization has been completed.
Quoted 4 lines
Since this check is part of the critical path for every single binder transaction, the performance plummeted when we started contending for the
mmap_lock. In this particular case, binder doesn't actually use the vma.
So why does binder_update_page_range() take the mmap_read_lock then use the cached vma in the reverted patch?
If you want to use it as a flag to see if the driver is initialized, why not use the cached address != 0?
Or better yet,
Quoted 2 lines
It only needs to know if the internal structure has been fully initialized and it is safe to use it.
This seems like a good reason to use your own rwsem. This is, essentially, rolling your own lock with smp_store_release()/smp_load_acquire() and a pointer which should not be cached.
Quoted 3 lines
FWIW, this had been the design for ~15 years. The original patch is
this: https://git.kernel.org/torvalds/c/457b9a6f09f0
Carlos Llamas
maintainerRe: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Quoted 22 lines · Liam R. Howlett
Quoted 8 lines · Carlos Llamas
The specifics are in the third patch of this patchset but the gist of it is that during ->mmap() handler, binder will complete the initialization of the
binder_allocstructure. With the last step of this process being the caching of the vma pointer. Since the ordering is protected with a barrier we can then checkalloc->vmato determine if the initialization has been completed.Quoted 4 lines
Since this check is part of the critical path for every single binder transaction, the performance plummeted when we started contending for the
mmap_lock. In this particular case, binder doesn't actually use the vma.So why does
binder_update_page_range()take themmap_read_lockthen use the cached vma in the reverted patch?If you want to use it as a flag to see if the driver is initialized, why not use the cached address != 0?
Or better yet,
Quoted 7 lines
Quoted 2 lines
It only needs to know if the internal structure has been fully initialized and it is safe to use it.
This seems like a good reason to use your own rwsem. This is, essentially, rolling your own lock with smp_store_release()/smp_load_acquire() and a pointer which should not be cached.
We can't use an rwsem to protect the initialization. We already have an alloc->mutex which would be an option. However, using it under ->mmap() would only lead to dead-locks with the mmap_lock.
I agree with you that we could use some other flag instead of the vma pointer to signal the initialization. I've actually tried several times to come up with a scenario in which caching the vma pointer becomes an issue to stop doing this altogether. However, I can't find anything concrete.
I don't think the current solution in which we do all these unnecessary vma lookups is correct. Instead, I'm currently working on a redesign of this section in which binder stops to allocate/insert pages manually. We should be making use of the page-fault handler and let the infra handle all the work. The overall idea is here:
https://lore.kernel.org/all/[email protected]/
It's hard to make the case for just dropping the vma pointer after ~15 years and take the performance hit without having an actual issue to support this idea. So I'll revert this for now and keep working on the page-fault solution.
Thanks Liam, I'll keep you in the loop.
Re: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Quoted 48 lines · Carlos Llamas
Quoted 22 lines · Liam R. Howlett
Quoted 8 lines · Carlos Llamas
The specifics are in the third patch of this patchset but the gist of it is that during ->mmap() handler, binder will complete the initialization of the
binder_allocstructure. With the last step of this process being the caching of the vma pointer. Since the ordering is protected with a barrier we can then checkalloc->vmato determine if the initialization has been completed.Quoted 4 lines
Since this check is part of the critical path for every single binder transaction, the performance plummeted when we started contending for the
mmap_lock. In this particular case, binder doesn't actually use the vma.So why does
binder_update_page_range()take themmap_read_lockthen use the cached vma in the reverted patch?If you want to use it as a flag to see if the driver is initialized, why not use the cached address != 0?
Or better yet,
Quoted 7 lines
Quoted 2 lines
It only needs to know if the internal structure has been fully initialized and it is safe to use it.
This seems like a good reason to use your own rwsem. This is, essentially, rolling your own lock with smp_store_release()/smp_load_acquire() and a pointer which should not be cached.
We can't use an rwsem to protect the initialization. We already have an
alloc->mutexwhich would be an option. However, using it under ->mmap() would only lead to dead-locks with themmap_lock.I agree with you that we could use some other flag instead of the vma pointer to signal the initialization. I've actually tried several times to come up with a scenario in which caching the vma pointer becomes an issue to stop doing this altogether. However, I can't find anything concrete.
I don't think the current solution in which we do all these unnecessary vma lookups is correct. Instead, I'm currently working on a redesign of this section in which binder stops to allocate/insert pages manually. We should be making use of the page-fault handler and let the infra handle all the work. The overall idea is here:
https://lore.kernel.org/all/[email protected]/
Quoted 5 lines
It's hard to make the case for just dropping the vma pointer after ~15 years and take the performance hit without having an actual issue to support this idea. So I'll revert this for now and keep working on the page-fault solution.
I came across this [1] when I was looking into something else and thought I'd double back and make sure your fix for this UAF is also included, since your revert will restore this bug.
I do still see the mmap_read_lock() in binder_update_page_range() vs the required mmap_write_lock(), at least in my branch.
[1] https://lore.kernel.org/all/[email protected]/
Thanks,
Liam
Carlos Llamas
maintainerRe: [RFC PATCH 2/3] Revert "android: binder: stop saving a pointer to the VMA"
Quoted 10 lines · Liam R. Howlett
I came across this [1] when I was looking into something else and thought I'd double back and make sure your fix for this UAF is also included, since your revert will restore this bug.
I do still see the
mmap_read_lock()inbinder_update_page_range()vs the requiredmmap_write_lock(), at least in my branch.
Thanks Liam, I believe you are correct. The UAF should trigger on newer releases after the revert of your patch. I'll try to reproduce the issue to confirm and will send the fix afterwards. This was a nice find!
Thanks,
--
Carlos Llamas
Carlos Llamas
maintainerRFC PATCH 3/3 binder: add lockless binder_alloc_(set|get)_vma()
In reply to Carlos LlamasBring back the original lockless design in binder_alloc to determine whether the buffer setup has been completed by the ->mmap() handler. However, this time use smp_load_acquire() and smp_store_release() to wrap all the ordering in a single macro call.
Also, add comments to make it evident that binder uses alloc->vma to determine when the binder_alloc has been fully initialized. In these scenarios acquiring the mmap_lock is not required.
--- drivers/android/binder_alloc.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-)
drivers/android/binder_alloc.c +12 -10
@@ -309,17 +309,16 @@ static int binder_update_page_range(struct binder_alloc *alloc, int allocate,return vma ? -ENOMEM : -ESRCH ; } +static inline void binder_alloc_set_vma (struct binder_alloc *alloc, +struct vm_area_struct *vma) +{ +smp_store_release (&alloc->vma, vma); +} +static inline struct vm_area_struct *binder_alloc_get_vma (struct binder_alloc *alloc) { -struct vm_area_struct *vma =NULL ; - -if (alloc->vma) { -/* Look at description in binder_alloc_set_vma */ -smp_rmb (); - vma = alloc->vma; - } -return vma; +return smp_load_acquire (&alloc->vma); }static bool debug_low_async_space_locked (struct binder_alloc *alloc,int pid)
@@ -382,6 +381,7 @@ static struct binder_buffer *binder_alloc_new_buf_locked(size_t size, data_offsets_size;int ret; +/* Check binder_alloc is fully initialized */ if (!binder_alloc_get_vma (alloc)) { binder_alloc_debug(BINDER_DEBUG_USER_ERROR, "%d: binder_alloc_buf, no vma\n",
@@ -777,7 +777,9 @@ int binder_alloc_mmap_handler(struct binder_alloc *alloc, buffer->free =1 ;binder_insert_free_buffer (alloc, buffer); alloc->free_async_space = alloc->buffer_size /2 ; - alloc->vma = vma; + +/* Signal binder_alloc is fully initialized */ +binder_alloc_set_vma (alloc, vma);return 0 ;
@@ -959,7 +961,7 @@ int binder_alloc_get_allocated_count(struct binder_alloc *alloc)*/ void binder_alloc_vma_close (struct binder_alloc *alloc) { - alloc->vma =0 ; +binder_alloc_set_vma (alloc,NULL ); }/**
Signature · 1 line
2.40.0.634.g4ca3ef3211-goog
Greg Kroah-Hartman
maintainerQuoted 7 lines · Carlos Llamas
This reverts commit
44e602b4e52f70f04620bbbf4fe46ecb40170bde.This caused a performance regression particularly when pages are getting reclaimed. We don't need to acquire the
mmap_lockto determine when the binder buffer has been fully initialized. A subsequent patch will bring back the lockless approach for this.
Quoted 8 lines
[cmllamas: resolved trivial conflicts with renaming of
alloc->mm]Cc Liam Howlett <[email protected]>Cc Suren Baghdasaryan <[email protected]>Signed-off-by Carlos Llamas <[email protected]>--- drivers/android/binder_alloc.c | 31 ++++++++++--------------------- 1 file changed, 10 insertions(+), 21 deletions(-)
Why is this series "RFC"? What needs to be done to be able to submit it as a real patch series?
Also, as the commits you are reverting are in older kernels, please properly cc: stable in the signed-off-by area, and add a fixes: tag for the commit you are reverting when you resend these as a real series.
thanks,
greg k-h
Carlos Llamas
maintainerQuoted 17 lines · Greg Kroah-Hartman
Quoted 7 lines · Carlos Llamas
This reverts commit
44e602b4e52f70f04620bbbf4fe46ecb40170bde.This caused a performance regression particularly when pages are getting reclaimed. We don't need to acquire the
mmap_lockto determine when the binder buffer has been fully initialized. A subsequent patch will bring back the lockless approach for this.Quoted 8 lines
[cmllamas: resolved trivial conflicts with renaming of
alloc->mm]Cc Liam Howlett <[email protected]>Cc Suren Baghdasaryan <[email protected]>Signed-off-by Carlos Llamas <[email protected]>--- drivers/android/binder_alloc.c | 31 ++++++++++--------------------- 1 file changed, 10 insertions(+), 21 deletions(-)
Quoted 2 lines
Why is this series "RFC"? What needs to be done to be able to submit it as a real patch series?
No real reason. Just wanted to get feedback from the mm folks first. I'll go ahead and submit the v1.
Quoted 4 lines
Also, as the commits you are reverting are in older kernels, please properly cc: stable in the signed-off-by area, and add a fixes: tag for the commit you are reverting when you resend these as a real series.
Sounds good, thanks!