RE: [tip:tracing/core] Revert "x86, bts: reenable ptrace branch trace support"

Metzger, Markus T
2009-06-11T08:31:06Z

>From: Peter Zijlstra [mailto:peterz@infradead.org]
>Sent: Thursday, June 11, 2009 10:09 AM
>To: Metzger, Markus T
>Cc: linux-kernel@vger.kernel.org; mingo@redhat.com; hpa@zytor.com; oleg@redhat.com;
>tglx@linutronix.de; mingo@elte.hu; linux-tip-commits@vger.kernel.org
>Subject: RE: [tip:tracing/core] Revert "x86, bts: reenable ptrace branch trace support"
>
>On Thu, 2009-06-11 at 08:17 +0100, Metzger, Markus T wrote:
>> >That would indeed keep the proposed ABI workable, what I'm still not
>> >liking is that this buffer is in-kernel, but I guess that might be
>> >something for other people to have an opinion on.
>>
>> The alternative would be to give a user-allocated buffer to the tracing h/w.
>>
>> We would need to take precautions to prevent the user from messing around
>> with that buffer while the h/w is writing to it. Other code uses the kernel-
>> allocated buffer plus copy_to_user() approach, as well.
>>
>> Further, it would require the user to interpret the various tracing formats,
>> whereas the existing interface provides an architecture-independent format.
>>
>>
>> Does anybody have concerns on using an in-kernel buffer and providing a
>> copy_to_user() interface?
>
>Ah, if you mmap() you can do without copy_to_user().

The user would still need to call the kernel to interpret the trace data,
which would then require copy_to_user() for the interpreted data.

>Either way, you have to make sure the buffer is mlocked() anyway, since
>you're wanting to fill it from interrupt context.
>
>The advantage (imo) from letting the user set it up is that you don't
>need those separate allocation routines.

I would still need to mlock() the buffer. Those separate allocation routines
do the accounting work of mlock() on an already non-pageable buffer.

If you don't like those separate allocation routines, we could extract the
accounting part from mlock() into separate functions and I could use those.
These changes would again be in-kernel without impacting the API.

>But yes, it would expose the data to the user, but one could keep it
>opaque data, without requiring the user to be able to interpret it.

See above, the user would then need to call the kernel to interpret the data.
We would achieve exactly the same thing in a more complicated way:
- there's a buffer which the user cannot use directly
- the buffer must be locked and must not go away
- the user needs to call the kernel to read trace records from the buffer

If we let the user setup the buffer, all we gain is some additional overhead.
The user needs to request pages from the kernel. Malloc needs to administrate
this memory. The user then gives the memory back to the kernel, which locks it
and gives it to the h/w.

regards,