tracing: make Entered !Send

[hawkw]

Motivation

The Entered guard returned by Span::enter represents entering and
exiting a span on the current thread. Calling Span::enter enters the
span, returning an Entered, and dropping the Entered ensures that
the span is exited. This ensures that all spans, once entered, are
eventually exited.

However, Entered has an auto-impl of Send, because it doesn't
contain any !Send types. This means that the Entered guard could
be sent to another thread and dropped. This would cause the original
thread to never exit the span,. and the thread to which the Entered
guard was sent would exit a span that it never observed an enter for.
This is incorrect.

Solution

This PR adds a *mut () field to Entered so that it no longer
implements Send. There's now a manual Sync impl so structs holding
an Entered can still be Sync.

Fixes #698

Signed-off-by: Eliza Weisman eliza@buoyant.io

[MikailBag]

Suggested change

	_not_send: PhantomData<*mut ()>,
	_not_send_but_sync: PhantomData<std::sync::MutexGuard<'static, ()>>,

It's a bit weird, but -1 unsafe, because you don't need to unsafe impl Sync

[hawkw]

oh that's clever! thanks!

unfortunately we can't do exactly what you've suggested, because this needs to compile with the std feature disabled, but I can do something similar.

[LucioFranco]

This isn't actually unsafe? We are not dereferencing this type, thus doesn't require unsafe.

[hawkw]

@LucioFranco the unsafe was necessary for manually implementing Sync.

[hawkw]

...and, it turns out this approach doesn't actually work in this specific case. Because tracing has conditional support for no_std, we can't use the std::sync version of MutexGuard. I thought we could use the MutexGuard from the spinlock implementation that's used as a fallback on no-std platforms, but I'd forgotten that this is defined in tracing-core, not tracing, and isn't publicly visible. I'll probably go back to the previous approach of just accepting the additional unsafe keyword necessary to manually impl Sync.