3 ** Keep exit code of traced process
4 See https://bugzilla.redhat.com/show_bug.cgi?id=105371 for details.
6 ** Automatic prototype discovery:
7 *** Use debuginfo if available
8 Alternatively, use debuginfo to generate configure file.
9 *** Mangled identifiers contain partial prototypes themselves
10 They don't contain return type info, which can change the
11 parameter passing convention. We could use it and hope for the
12 best. Also they don't include the potentially present hidden this
14 ** Automatically update list of syscalls?
15 ** More operating systems (solaris?)
16 ** Get rid of EVENT_ARCH_SYSCALL and EVENT_ARCH_SYSRET
17 ** Implement displaced tracing
18 A technique used in GDB (and in uprobes, I believe), whereby the
19 instruction under breakpoint is moved somewhere else, and followed
20 by a jump back to original place. When the breakpoint hits, the IP
21 is moved to the displaced instruction, and the process is
22 continued. We avoid all the fuss with singlestepping and
24 ** Create different ltrace processes to trace different children
26 *** mark some symbols as exported
27 For PLT hits, only exported prototypes would be considered. For
28 symtab entry point hits, all would be.
31 This would be useful for replacing the arg1, emt2 etc.
33 *** parameter pack improvements
34 The above format tweaks require that packs that expand to no types
35 at all be supported. If this works, then it should be relatively
36 painless to implement conditionals:
38 | void ptrace(REQ=enum(PTRACE_TRACEME=0,...),
39 | if[REQ==0](pack(),pack(pid_t, void*, void *)))
41 This is of course dangerously close to a programming language, and
42 I think ltrace should be careful to stay as simple as possible.
43 (We can hook into Lua, or TinyScheme, or some such if we want more
44 general scripting capabilities. Implementing something ad-hoc is
45 undesirable.) But the above can be nicely expressed by pattern
48 | void ptrace(REQ=enum[int](...)):
50 | [REQ==1 or REQ==2] => (pid_t, void*)
51 | [true] => (pid_t, void*, void*);
55 | int open(string, FLAGS=flags[int](O_RDONLY=00,...,O_CREAT=0100,...)):
56 | [(FLAGS & 0100) != 0] => (flags[int](S_IRWXU,...))
58 This would still require pretty complete expression evaluation.
59 _Including_ pointer dereferences and such. And e.g. in accept, we
62 | int accept(int, +struct(short, +array(hex(char), X-2))*, (X=uint)*);
64 Perhaps we should hook to something after all.
66 *** system call error returns
68 This is closely related to above. Take the following syscall
71 | long read(int,+string0,ulong);
73 string0 means the same as string(array(char, zero(retval))*). But
74 if read returns a negative value, that signifies errno. But zero
75 takes this at face value and is suspicious:
77 | read@SYS(3 <no return ...>
78 | error: maximum array length seems negative
79 | , "\n\003\224\003\n", 4096) = -11
81 Ideally we would do what strace does, e.g.:
83 | read@SYS(3, 0x12345678, 4096) = -EAGAIN
86 Some calls result in setting errno. Somehow mark those, and on
87 failure, show errno. System calls return errno as a negative
88 value (see the previous point).
90 *** second conversions?
91 This definitely calls for some general scripting. The goal is to
92 have seconds in adjtimex calls show as e.g. 10s, 1m15s or some
95 *** format should take arguments like string does
96 Format should take value argument describing the value that should
97 be analyzed. The following overwriting rules would then apply:
99 | format | format(array(char, zero)*) |
100 | format(LENS) | X=LENS, format[X] |
102 The latter expanded form would be canonical.
104 This depends on named arguments and parameter pack improvements
105 (we need to be able to construct parameter packs that expand to
108 *** More fine-tuned control of right arguments
109 Combination of named arguments and some extensions could take care
112 | void func(X=hide(int*), long*, +pack(X)); |
114 This would show long* as input argument (i.e. the function could
115 mangle it), and later show the pre-fetched X. The "pack" syntax is
116 utterly undeveloped as of now. The general idea is to produce
117 arguments that expand to some mix of types and values. But maybe
118 all we need is something like
120 | void func(out int*, long*); |
122 ltrace would know that out/inout/in arguments are given in the
123 right order, but left pass should display in and inout arguments
124 only, and right pass then out and inout. + would be
125 backward-compatible syntactic sugar, expanded like so:
127 | void func(int*, int*, +long*, long*); |
128 | void func(in int*, in int*, out long*, out long*); |
130 This is useful in particular for:
132 | ulong mbsrtowcs(+string(array(uint, zero(arg3))), string*, ulong, addr); |
134 Where we would like to render arg2 on the way in, and arg1 on the
137 But sometimes we may want to see a different type on the way in and
138 on the way out. E.g. in asprintf, what's interesting on the way in
139 is the address, but on the way out we want to see buffer contents.
140 Does something like the following make sense?
142 | void func(X=void*, long*, out string(X)); |
144 ** Support for functions that never return
145 This would be useful for __cxa_throw, presumably also for longjmp
146 (do we handle that at all?) and perhaps a handful of others.
148 ** Support flag fields
149 enum-like syntax, except disjunction of several values is assumed.
151 We currently can't define time_t on 32bit machines. That mean we
152 can't describe a range of time-related functions.
154 ** Support signed char, unsigned char, char
155 Also, don't format it as characted by default, string lens can do
156 it. Perhaps introduce byte and ubyte and leave 'char' as alias of
157 one of those with string lens applied by default.
159 ** Support fixed-width types
160 Really we should keep everything as {u,}int{8,16,32,64} internally,
161 and have long, short and others be translated to one of those
162 according to architecture rules. Maybe this could be achieved by a
163 per-arch config file with typedefs such as:
165 | typedef ulong = uint8_t; |
167 ** Support for ARM/AARCH64 types
168 - ARM and AARCH64 both support half-precision floating point
169 - there are two different half-precision formats, IEEE 754-2008
170 and "alternative". Both have 10 bits of mantissa and 5 bits of
171 exponent, and differ only in how exponent==0x1F is handled. In
172 IEEE format, we get NaN's and infinities; in alternative
173 format, this encodes normalized value -1S × 2¹⁶ × (1.mant)
174 - The Floating-Point Control Register, FPCR, controls: — The
175 half-precision format where applicable, FPCR.AHP bit.
176 - AARCH64 supports fixed-point interpretation of {,double}words
177 - e.g. fixed(int, X) (int interpreted as a decimal number with X
178 binary digits of fraction).
179 - AARCH64 supports 128-bit quad words in SIMD
181 ** Some more functions in vect might be made to take const*
182 Or even marked __attribute__((pure)).
184 ** pretty printer support
185 GDB supports python pretty printers. We migh want to hook this in
186 and use it to format certain types.
189 ** After a clone(), syscalls may be seen as sysrets in s390 (see trace.c:syscall_p())