[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: asynchronous detach



> So, the intention is that -EINPROGRESS can be returned only on a
> utrace_set_events(task, engine, 0), right?

No, for any call when some bits had been enabled before and there hasn't
been an intervening safe point.  My idea was that it would return 0 only
when it's sure that no disabled callback might be made.  You'd get
-EINPROGRESS any time we aren't 100% positive of that guarantee.

> Actually, I think it would also be useful to just have a
> utrace_clear_events_sync() that encapsulates the above call. I can see
> use for it outside of an asynchronous detach, for cases when one needs
> to just turn tracing events off on a thread. (It is definitely not
> recommended for debugger/probes usage with breakpoints already set in
> user code, but would be useful for someone doing non-invasive syscall
> and process lifetime tracing).

I mentioned utrace_set_events_sync.

> Yes, this does take care of the thread about to die case too.

I've written code to implement most of this.  In working through it, I came
across a couple of other wrinkles I hadn't thought about before.  These
come up in thinking about the possible interactions with callbacks that
return UTRACE_DETACH.

Firstly, you can't call *_sync freely if any of your callbacks ever use
UTRACE_DETACH.  When any callback returns UTRACE_DETACH, immediately the
engine pointer is only kept alive by RCU.  You can't make a blocking call
with rcu_read_lock() held, so you can't be keeping it alive via RCU when
you all *_sync.

You can still use it, just not "freely".  What that means is that you need
some other synchronization with your callbacks.  If your callback safely
updates a data structure saying "already doing the detach", then you can
synchronize with that update and check it before calling utrace_detach_sync.
It takes a little thought to do that without deadlock, but it's doable.

There are already special cases for the report_death callback using
UTRACE_DETACH.  We can see that a death callback might be in progress just
from the task/utrace data structures, without actually looking at the
engine pointer passed in.  So we can relax that rule to allow using
UTRACE_DETACH in report_death without making *_sync unsafe.

The same sort of problems makes me unsure we can use interruptible blocks.

I'll think about this some more.


Thanks,
Roland


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]