uprobes: relax valid_vma check for VM_MAYSHARE
Subsystems (2)
PATCH 1/1 uprobes: relax valid_vma check for VM_MAYSHARE
valid_vma returns false when registering a uprobe if the provided VMA is writable (VM_WRITE) or sharable (VM_MAYSHARE). This causes perf_event_open [1] sys calls to fail silently. A successful return code is delivered to the caller even though the uprobe wasn't actually attached [2][3].
Remove the latter restriction (VM_MAYSHARE) from this check to allow registering uprobes on code that has been "dual mapped" into a process' memory space. This is helpful when instrumenting just-in-time compiled code such as that of Android Runtime (ART) [4]. ART maps a memfd twice, once as RW and once as RX, to uphold W^X for security (defense in depth), and also to provide better performance (no need to call mprotect before and after writing) [5].
uprobes already work for code that is ahead-of-time (AOT) compiled by the Android Runtime (ART), as it resides in a static ELF file [6]. In order to attach to just-in-time (JIT) compiled code, the Android OS itself can coordinate with ART to isolate to-be-instrumented code in a separate memfd, which will be left untouched for the duration of a uprobe being attached. Thus, while the VMAs inside the memfd will *technically* have the VM_MAYSHARE flag, the system will ensure that they will not be written to again until after any uprobe as been detached.
---
We've created a working proof-of-concept in Android that demonstrates what is described in the last paragraph of the commit message. Thus, we introduce this patch to understand the reasoning behind the original VM_SHARED (later converted to VM_MAYSHARE) restriction, and the risks that may be associated with relaxing it. It's not clear to me why the restriction is there, and we'd like to get feedback on why it is or is not still relevant.
kernel/events/uprobes.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/events/uprobes.c +1 -1
@@ -123,7 +123,7 @@ struct xol_area {*/ static bool valid_vma (struct vm_area_struct *vma,bool is_register) { -vm_flags_t flags =VM_HUGETLB |VM_MAYEXEC |VM_MAYSHARE ; +vm_flags_t flags =VM_HUGETLB |VM_MAYEXEC ;if (is_register) flags |=VM_WRITE ;
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Quoted 47 lines · Matt Gilbride
valid_vmareturns false when registering a uprobe if the provided VMA is writable (VM_WRITE) or sharable (VM_MAYSHARE). This causesperf_event_open[1] sys calls to fail silently. A successful return code is delivered to the caller even though the uprobe wasn't actually attached [2][3].Remove the latter restriction (
VM_MAYSHARE) from this check to allow registering uprobes on code that has been "dual mapped" into a process' memory space. This is helpful when instrumenting just-in-time compiled code such as that of Android Runtime (ART) [4]. ART maps a memfd twice, once as RW and once as RX, to uphold W^X for security (defense in depth), and also to provide better performance (no need to callmprotectbefore and after writing) [5].uprobes already work for code that is ahead-of-time (AOT) compiled by the Android Runtime (ART), as it resides in a static ELF file [6]. In order to attach to just-in-time (JIT) compiled code, the Android OS itself can coordinate with ART to isolate to-be-instrumented code in a separate memfd, which will be left untouched for the duration of a uprobe being attached. Thus, while the VMAs inside the memfd will *technically* have the
VM_MAYSHAREflag, the system will ensure that they will not be written to again until after any uprobe as been detached.Signed-off-by Matt Gilbride <[email protected]>---
We've created a working proof-of-concept in Android that demonstrates what is described in the last paragraph of the commit message. Thus, we introduce this patch to understand the reasoning behind the originalVM_SHARED(later converted toVM_MAYSHARE) restriction, and the risks that may be associated with relaxing it. It's not clear to me why the restriction is there, and we'd like to get feedback on why it is or is not still relevant.kernel/events/uprobes.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)kernel/events/uprobes.c +0
-0
kernel/events/uprobes.c struct xol_area { · line 129
Quoted 8 lines
kernel/events/uprobes.c +1
-1@@ -123,7 +123,7 @@ struct xol_area {*/ static bool valid_vma (struct vm_area_struct *vma,bool is_register) { -vm_flags_t flags =VM_HUGETLB |VM_MAYEXEC |VM_MAYSHARE ; +vm_flags_t flags =VM_HUGETLB |VM_MAYEXEC ;if (is_register) flags |=VM_WRITE ;
It cannot possibly work, unless I am missing something important.
You probably tested this against a kernel pre-6e3092d788be1de0aac56b81fc17551c76645cdf.
Before that rework, you would be inserting anonymous pages in shared mappings, which is pretty much broken.
If you want a double RX mapping where you can have anon pages in it, create that one as MAP_PRIVATE.
Signature · 3 lines
Cheers, David / dhildenb
Peter Zijlstra
maintainerQuoted 2 lines · Matt Gilbride
ART maps a memfd twice, once as RW and once as RX, to uphold W^X for security (defense in depth),
I'll argue this is no defence at all. As long as there is a writable mapping for an executable page, you've lost. You have effectively violated W^X.