Change Details

Some things to note: - Are the `warn*()`/`err*()` calls appropriate here? DTrace's `xywarn()` and `dt_handle_liberr()` are not really want I want. - `dt_sugar_kinst_find_caller_func()` has x86-only code, we'll have to visit it again when kinst is ported to new platforms. Perhaps an `#ifdef` would be better than splitting the code into multiple files. Bugs I noticed so far: Predicate `/self->ts/` gives a segfault when more than one newly generated clauses have it. The following script reproduces the bug: ``` #!/usr/sbin/dtrace -s kinst::vm_page_mvqueue:entry { self->ts = timestamp; } kinst::vm_page_mvqueue:return /self->ts/ { @[probefunc] = quantize(timestamp - self->ts); self->ts = 0; } ```

The following code implements inline tracing for the kinst DTrace provider. Briefly explained, what the code does is, for each probe of the form: ``` kinst::<inline_func>:<entry/return> ``` libdtrace checks to see if `<inline_func>` is indeed an inline function, where in this case it finds all inline copies of it and creates new probes for each one of them. Otherwise, it converts the probe to an FBT one so that we don't duplicate FBT's functionality in kinst. Some things to note: Are the `warn*()`/`err*()` calls appropriate here? DTrace's `xywarn()` and `dt_handle_liberr()` are not really want I want. `dt_sugar_kinst_find_caller_func()` has x86-only code, we'll have to visit it again when kinst is ported to new platforms. Perhaps an `#ifdef` would be better than splitting the code into multiple files. I'm ignoring functions (with a warning) that do not start with `push %rbp`, since kinst(4) currently also ignores such functions. I'm planning to change kinst's logic to search for `pop %rbp` anywhere in the function, instead of checking if the first instruction is `push %rbp`.

Some things to note:The following code implements inline tracing for the kinst DTrace provider. - Are the `warn*()`/`err*()` calls appropriate here?Briefly explained, what the code does is, DTrace's `xywarn()` andfor each probe of the form: ``` `dt_handle_liberr()` are not really want I want.kinst::<inline_func>:<entry/return> - `dt_sugar_kinst_find_caller``` libdtrace checks to see if `<inline_func()` has x86-only code>` is indeed an inline function, we'll have to visit itwhere again when kinst is ported to new platforms. Perhaps an `#ifdef` would bein this case it finds all inline copies of it and creates new probes for each better than splitting the code into multiple files. Bugs I noticed so far: Predicate `/self->ts/` gives a segfault when more than one newly generatedone of them. Otherwise, it converts the probe to an FBT one so that we don't clauses have it. The following script reproduces the bug:duplicate FBT's functionality in kinst. ``` #!/usr/sbin/dtrace -sSome things to note: kinst::vm_page_mvqueue:entryAre the `warn*()`/`err*()` calls appropriate here? DTrace's `xywarn()` and {`dt_handle_liberr()` are not really want I want. `dt_sugar_kinst_find_caller_func()` has x86-only code, we'll have to visit it self->ts = timestamp;again when kinst is ported to new platforms. Perhaps an `#ifdef` would be }better than splitting the code into multiple files. kinst::vm_page_mvqueue:returnI'm ignoring functions (with a warning) that do not start with `push %rbp`, /self->ts/since kinst(4) currently also ignores such functions. I'm planning to change {kinst's logic to search for `pop %rbp` anywhere in the function, instead of @[probefunc] = quantize(timestamp - self->ts); self->ts = 0; } ```checking if the first instruction is `push %rbp`.