Getting function names with lttng-ust-cyg-profile.so
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Thanks,
Mathieu
Quoted 36 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned user to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information (function names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Signature · 3 lines
Mathieu Desnoyers EfficiOS Inc. http://www.efficios.com
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.html
Thanks,
Paul
Quoted 48 lines · Mathieu Desnoyers
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Thanks,
Mathieu
Quoted 36 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned user to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information (function names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Signature · 3 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division
+1 on that.
I think we should have a way for UST to store the function names in the metadata, so the trace remains valid for any viewer that correctly supports CTF.
I think Mathieu Desnoyers said once that this requires a modification to the CTF spec, so let's start raising out voice for this...
As Paul mentioned, he has a solution, and I have a somewhat different solution (which I will share sometime in the near future), but I still think that having the function names in the metadata is better.
Amit Margalit
IBM XIV - Storage Reinvented
XIV-NAS Development Team
Tel. 03-689-7774
Fax. 03-689-7230
From: "Woegerer, Paul" <[email protected]> To: <[email protected]>, Mathieu Desnoyers <[email protected]> Cc: lttng-dev <[email protected]> Date: 09/10/2013 10:01 AM Subject: Re: [lttng-dev] Getting function names with
lttng-ust-cyg-profile.so
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.html
Thanks,
Paul
Quoted 7 lines · Mathieu Desnoyers
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Quoted 14 lines
Thanks,
Mathieu
Quoted 9 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned
user
Quoted 2 lines
Quoted 2 lines
to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information
(function
Quoted 25 lines
Quoted 25 lines
names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Signature · 9 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division _______________________________________________ lttng-dev mailing list [email protected] http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Hi Alex and Mathieu,
A year ago we discussed this and said iirc: "the addresses are a good first step, we'll do more later." and "It would be nice to dump the stabs into the metadata of the ctf trace"
I would still maintain that this seems to be the way to go.
A technical hurdle that is probably trivial to our high level tracing vanguards would be to handle dlopens and libs that replace other libs.
I would suggest something like this in TSDL:
location {
address = 0xdeadbeef;
name = "get_actual_lost_events";
}location {
address = 0xf00ff00f;
name = "get_pretend_lost_events";
// optional
timestart = 123456;
timeend = 123457;
}The metadata will get big and dynamic though.
Quoted 48 lines · Mathieu Desnoyers
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Thanks,
Mathieu
Quoted 36 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned user to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information (function names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Alex brought up an excellent point,
these locations should be events since there can be address collisions.
A default event for location with a payload of address and name would be sufficient I think. DlOpen will create many events then.
Quoted 83 lines · Matthew Khouzam
Hi Alex and Mathieu,
A year ago we discussed this and said iirc: "the addresses are a good first step, we'll do more later." and "It would be nice to dump the stabs into the metadata of the ctf trace"
I would still maintain that this seems to be the way to go.
A technical hurdle that is probably trivial to our high level tracing vanguards would be to handle dlopens and libs that replace other libs.
I would suggest something like this in TSDL:
location { address = 0xdeadbeef; name = "get_actual_lost_events"; }location { address = 0xf00ff00f; name = "get_pretend_lost_events"; // optional timestart = 123456; timeend = 123457; }The metadata will get big and dynamic though.
Quoted 7 lines · Mathieu Desnoyers
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Quoted 41 lines
Thanks,
Mathieu
Quoted 36 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned user to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information (function names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Quoted 10 lines · Paul
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.html
This is a very interesting approach, +1 from me on that.
Quoted 54 lines
Thanks,
PaulQuoted 48 lines · Mathieu Desnoyers
We might want to investigate doing a side-program that gathers the executables on the system, and lookup the symbols from the ELF. We could save those in a bin/ subdirectory of a CTF trace. All we need is instrumentation of the dynamic linker, and to know the executable names associated with PIDs. There is a UST feature request for dynamic linker instrumentation.
Thanks,
Mathieu
Quoted 36 lines · * Alexandre Montplaisir ([email protected]) wrote:
Hi all,
I've recently started playing with liblttng-ust-cyg-profile.so (aka, getting UST events from -finstrument-functions), and I have to say it's pretty nifty! I haven't done any benchmarks, but it's certainly faster than the typical
printf()that people use with it...However, in the resulting trace, one only gets the addresses of the functions. I understand how it's relatively "easy" for the seasoned user to use nm or addr2line to get the actual function names, but would it possible - and how hard would it be - to have this information (function names) directly in the trace?
I'm trying to leverage this feature in Eclipse TMF to display a call stack for such UST traces. And to be honest, displaying a call stack with only the function addresses is completely useless, we need the function names.
We could have the user import a text file (which he can generate with "nm appname > file.txt" for example). But then he needs the original binary, which he might not have. And that binary needs to be compiled with debugging symbols. If the function name information was already in the trace, it would make the user experience much better, and our job much easier! ;)
Thoughts?
Thanks,
Alex_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Quoted 9 lines · Matthew Khouzam
Quoted 8 lines · Paul
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
Quoted 3 lines
Quoted 2 lines
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.htmlThis is a very interesting approach, +1 from me on that.
Thanks.
With that approach no redundant data (that is already available as debuginfo) gets replicated in the actual trace data.
Only the bare minimum of information gets traced to allow you at any time to map a VM address to a debuginfo address + debuginfo location.
Signature · 3 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division
I agree with Paul, that no redundant data gets replicated with his approach, and my only concern is that this approach really forces a viewer to be sequential.
Maybe "forces" is too strong a word - but a viewer than wants to let you "roam" the trace freely will have to read the entire trace to figure out the mapping between address and symbol at each point in time.
At this time, we keep 10GB worth of LTTng traces in our system, but future models will certainly use more. A user asking to go to the end of the trace will have to wait until the entire trace is read in order to see correct translations.
I have a different solution, which I think I have explained here before:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021263.html
I vote for adding this to the metadata. It can be in addition to the ust_baddr events suggeted by Paul.
Amit
Amit Margalit
IBM XIV - Storage Reinvented
XIV-NAS Development Team
Tel. 03-689-7774
Fax. 03-689-7230
From: "Woegerer, Paul" <[email protected]> To: Matthew Khouzam <[email protected]> Cc: lttng-dev <[email protected]>, Mathieu Desnoyers <[email protected]> Date: 09/10/2013 06:47 PM Subject: Re: [lttng-dev] Getting function names with
lttng-ust-cyg-profile.so
Quoted 9 lines · Matthew Khouzam
Quoted 8 lines · Paul
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
Quoted 3 lines
Quoted 2 lines
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.htmlThis is a very interesting approach, +1 from me on that.
Thanks.
With that approach no redundant data (that is already available as debuginfo) gets replicated in the actual trace data.
Only the bare minimum of information gets traced to allow you at any time to map a VM address to a debuginfo address + debuginfo location.
Signature · 9 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division _______________________________________________ lttng-dev mailing list [email protected] http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Quoted 4 lines · Amit Margalit
I agree with Paul, that no redundant data gets replicated with his approach, and my only concern is that this approach really forces a viewer to be sequential.
Quoted 8 lines
Maybe "forces" is too strong a word - but a viewer than wants to let you "roam" the trace freely will have to read the entire trace to figure out the mapping between address and symbol at each point in time.
At this time, we keep 10GB worth of LTTng traces in our system, but future models will certainly use more. A user asking to go to the end of the trace will have to wait until the entire trace is read in order to see correct translations.
We could provide a solution to this problem with my approach by emitting an update of the shared object state info every n x K events (configurable).
Assuming we have a 10GB trace data set, we could emit a full shared object state dump after every 100K events of regular trace data (with the same baddr_init events we emit at session_start time). By doing so you don't need to start reading the entire trace from the beginning. Just start reading 100K events before the events you are interested in, and you can guarantee to find a "key frame" for shared object state info.
Note that this is the same concept as used by video compression/streaming:
I-frame, P-frame, P-frame, P-frame, ..., I-frame, P-frame, P-frame, P-frame, ...*
*See: http://en.wikipedia.org/wiki/Video_compression_picture_types
Best,
Paul*
**
*
Quoted 42 lines
*
**I have a different solution, which I think I have explained here before:
**_http://lists.lttng.org/pipermail/lttng-dev/2013-August/021263.html_******
* *
**I vote for adding this to the metadata. It can be in addition to theust_baddrevents suggeted by Paul.****
* *
**Amit****
* *
**Amit Margalit****
**IBM XIV **- /Storage Reinvented/****
**XIV-NAS Development Team****
**Tel. 03**-689-7774****
**Fax. 03-689-7230****
* *
* *
* *
**From: **"Woegerer, Paul" <[email protected]>****
**To: **Matthew Khouzam <[email protected]>****
**Cc: **lttng-dev <[email protected]>, Mathieu
Desnoyers <[email protected]>****
**Date: **09/10/2013 06:47 PM****
**Subject: **Re: [lttng-dev] Getting function names with
lttng-ust-cyg-profile.so****
*
------------------------------------------------------------------------
*
* *Quoted 11 lines · * * **On 09/10/2013 05:37 PM, Matthew Khouzam wrote:
Quoted 10 lines · Paul
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
That is one of the reasons why I have submitted:
**http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.html**
Quoted 22 lines
Quoted 1 line
This is a very interesting approach, +1 from me on that.
Thanks.
With that approach no redundant data (that is already available as debuginfo) gets replicated in the actual trace data.
Only the bare minimum of information gets traced to allow you at any time to map a VM address to a debuginfo address + debuginfo location.Signature · 12 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <**http://go.mentor.com/sourceryanalyzer**> Mentor Graphics, Embedded Software Division _______________________________________________ lttng-dev mailing list [email protected] **http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev** * * *
*
**
*
Signature · 3 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division
_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
This kind of a solution is viable.
Here are the concerns we still need to hammer out for this - Seeking to an arbitrary time means that our events (P frames by analogy) need to point to the full shared object state dump (the I-frame) somehow. In video compression, the decoder (trace viewer in our analogy) is assumed to be receiving the stream sequentially and therefore keeps a copy of N previous frames (and the last I-frame).
Perhaps in CTF we can circumvent this problem by storing a field in one of the context headers that will allow us to quickly seek to the trace position where the full state dump is stored.
Emitting such a large set of events could happen at the same time that the system tries to emit high rate of events, which could cause loss of events.
While loss of events is something we have to consider "possible", I don't like to add to the chances of this happening.
The reason I think putting this in the metadata is preferable is that this keeps things (IMHO) more in the spirit of the CTF format -
=> The trace files are self-contained, the metadata is in the metadata stream, and in my humble opinion, the symbolic name of a function is metadata.
=> The writing of pure application events / tracepoints is not burdened by writing some overhead (albeit an important kind of overhead). => The viewers retain the same type of simplicity that already exists.
This is why I really liked Matthew Khouzam's concept of writing the symbols in the metadata with validity start-time.
Amit
Amit Margalit
IBM XIV - Storage Reinvented
XIV-NAS Development Team
Tel. 03-689-7774
Fax. 03-689-7230
From: "Woegerer, Paul" <[email protected]> To: Amit Margalit/Israel/IBM@IBMIL Cc: lttng-dev <[email protected]>, Mathieu Desnoyers <[email protected]>, Matthew Khouzam <[email protected]> Date: 09/11/2013 03:24 PM Subject: Re: [lttng-dev] Getting function names with
lttng-ust-cyg-profile.so
On 09/11/2013 11:12 AM, Amit Margalit wrote:
I agree with Paul, that no redundant data gets replicated with his approach, and my only concern is that this approach really forces a viewer to be sequential.
Maybe "forces" is too strong a word - but a viewer than wants to let you "roam" the trace freely will have to read the entire trace to figure out the mapping between address and symbol at each point in time.
At this time, we keep 10GB worth of LTTng traces in our system, but future models will certainly use more. A user asking to go to the end of the trace will have to wait until the entire trace is read in order to see correct translations.
We could provide a solution to this problem with my approach by emitting an update of the shared object state info every n x K events (configurable).
Assuming we have a 10GB trace data set, we could emit a full shared object state dump after every 100K events of regular trace data (with the same baddr_init events we emit at session_start time). By doing so you don't need to start reading the entire trace from the beginning. Just start reading 100K events before the events you are interested in, and you can guarantee to find a "key frame" for shared object state info.
Note that this is the same concept as used by video compression/streaming:
I?frame, P?frame, P?frame, P?frame, ..., I?frame, P?frame, P?frame, P?frame, ...
See: http://en.wikipedia.org/wiki/Video_compression_picture_types
Best,
Paul
I have a different solution, which I think I have explained here before:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021263.html
I vote for adding this to the metadata. It can be in addition to the ust_baddr events suggeted by Paul.
Amit
Amit Margalit
IBM XIV - Storage Reinvented
XIV-NAS Development Team
Tel. 03-689-7774
Fax. 03-689-7230
From: "Woegerer, Paul" <[email protected]> To: Matthew Khouzam <[email protected]> Cc: lttng-dev <[email protected]>, Mathieu Desnoyers <[email protected]> Date: 09/10/2013 06:47 PM Subject: Re: [lttng-dev] Getting function names with
lttng-ust-cyg-profile.so
Quoted 9 lines · Matthew Khouzam
Quoted 8 lines · Paul
Hi Alexandre,
For trivial examples you can go with 'nm -CS' (or the like), but when you start to use liblttng-ust-cyg-profile.so in combination with shared objects you will need to record base address information as well (to allow you map a virtual memory address at a given point in time to offset and path of a shared object (or executable)).
Quoted 3 lines
Quoted 2 lines
That is one of the reasons why I have submitted:
http://lists.lttng.org/pipermail/lttng-dev/2013-August/021264.htmlThis is a very interesting approach, +1 from me on that.
Thanks.
With that approach no redundant data (that is already available as debuginfo) gets replicated in the actual trace data.
Only the bare minimum of information gets traced to allow you at any time to map a VM address to a debuginfo address + debuginfo location.
Signature · 17 lines
Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division _______________________________________________ lttng-dev mailing list [email protected] http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev -- Paul Woegerer, SW Development Engineer Sourcery Analyzer <http://go.mentor.com/sourceryanalyzer> Mentor Graphics, Embedded Software Division
_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev