On Wed, 24 Mar 2021 at 14:21, Peter Zijlstra peterz@infradead.org wrote:
On Wed, Mar 24, 2021 at 02:01:56PM +0100, Peter Zijlstra wrote:
On Wed, Mar 24, 2021 at 01:53:48PM +0100, Peter Zijlstra wrote:
On Wed, Mar 24, 2021 at 12:24:59PM +0100, Marco Elver wrote:
Encode information from breakpoint attributes into siginfo_t, which helps disambiguate which breakpoint fired.
Note, providing the event fd may be unreliable, since the event may have been modified (via PERF_EVENT_IOC_MODIFY_ATTRIBUTES) between the event triggering and the signal being delivered to user space.
Signed-off-by: Marco Elver elver@google.com
v2:
- Add comment about si_perf==0.
kernel/events/core.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
diff --git a/kernel/events/core.c b/kernel/events/core.c index 1e4c949bf75f..0316d39e8c8f 100644 --- a/kernel/events/core.c +++ b/kernel/events/core.c @@ -6399,6 +6399,22 @@ static void perf_sigtrap(struct perf_event *event) info.si_signo = SIGTRAP; info.si_code = TRAP_PERF; info.si_errno = event->attr.type;
- switch (event->attr.type) {
- case PERF_TYPE_BREAKPOINT:
info.si_addr = (void *)(unsigned long)event->attr.bp_addr;info.si_perf = (event->attr.bp_len << 16) | (u64)event->attr.bp_type;Ahh, here's the si_perf user. I wasn't really clear to me what was supposed to be in that field at patch #5 where it was introduced.
Would it perhaps make sense to put the user address of struct perf_event_attr in there instead? (Obviously we'd have to carry it from the syscall to here, but it might be more useful than a random encoding of some bits therefrom).
Then we can also clearly document that's in that field, and it might be more useful for possible other uses.
Something like so...
Ok possibly something like so, which also gets the data address right for more cases.
It'd be nice if this could work. Though I think there's an inherent problem (same as with fd) with trying to pass a reference back to the user, while the user can concurrently modify that reference.
Let's assume that user space creates new copies of perf_event_attr for every version they want, there's still a race where the user modifies an event, and concurrently in another thread a signal arrives. I currently don't see a way to determine when it's safe to free a perf_event_attr or reuse, without there still being a chance that a signal arrives due to some old perf_event_attr. And for our usecase, we really need to know a precise subset out of attr that triggered the event.
So the safest thing I can see is to stash a copy of the relevant information in siginfo, which is how we ended up with encoding bits from perf_event_attr into si_perf.
One way around this I could see is that we know that there's a limited number of combinations of attrs, and the user just creates an instance for every version they want (and hope it doesn't exceed some large number). Of course, for breakpoints, we have bp_addr, but let's assume that si_addr has the right version, so we won't need to access perf_event_attr::bp_addr.
But given the additional complexities, I'm not sure it's worth it. Is there a way to solve the modify-signal-race problem in a nicer way?
Thanks, -- Marco