On Mon, May 6, 2019 at 7:58 PM Steven Rostedt <rostedt@xxxxxxxxxxx> wrote:
>
> > Notice? We'd not even have to look up any values. We'd literally just
> > do something like
> >
> > int offset = locked_atomic_read(ip+1);
> > return int3_emulate_call(ip, ip+5+offset);
> >
> > and it would be *atomic* with respect to whatever other user that
> > updates the instruction, as long as they update the offset with a
> > "xchg" instruction.
>
> Honestly, I'm not really sure what you are trying to do here.
>
> Are you talking about making the update to the code in the int3
> handler?
No. The above would be pretty much the entirely of the the ftrace_int3_handler.
It would emulate the call that has had its first byte overwritten by
'int3'. Without doing any lookups of what it was supposed to change
the call to, because it simply depends on what the rewriting code is
doing on another CPU (or on the same CPU - it wouldn't care).
So no need to look up anything, not at int3 time, and not at return
time. It would just emulate the instruction atomically, with no state,
and no need to look up what the 'ip' instruction is at the time.
It could literally just use a single flag: "is ftrace updating call
instructions". Add another flag for the "I'm nop'ing out call
instructions" so that it knows to emulate a jump-over instead. That's
it.
Because all the actual *values* would be entirely be determined by the
actual rewriting that is going on independently of the 'int3'
exception.
Linus
