Fix race when falling back from RDMA to TCP

[legionxiong]

What problem does this PR solve?

Issue Number: #3405

Problem Summary:

RdmaEndpoint::_state is accessed concurrently by the RDMA handshake,
TCP event handling, and completion handling paths, but was not atomic.
This causes a C++ data race.

During TCP fallback, RdmaTransport::_rdma_state and
RdmaEndpoint::_state also form a logical state transition. A TCP event
must not observe FALLBACK_TCP before the preceding RDMA_OFF update is
visible, otherwise it may start normal TCP message processing with a
partially published transport state.

What is changed and the side effects?

Changed:

• Change RdmaEndpoint::_state to butil::atomic<State>.
• Set RdmaTransport::_rdma_state to RDMA_OFF before publishing
  RdmaEndpoint::_state as FALLBACK_TCP.
• Publish FALLBACK_TCP with memory_order_release.
• Load the handshake state with memory_order_acquire in
  OnNewDataFromTcp(). When it observes FALLBACK_TCP, this acquire load
  pairs with the release store and makes the preceding RDMA_OFF update
  visible before normal TCP message processing starts.
• Use memory_order_relaxed for all other handshake-state transitions and
  observations because they do not publish or consume related data.
• Add comments documenting the acquire/release synchronization and why
  relaxed ordering is sufficient for the other accesses.

Side effects:

• Performance effects:

  The acquire load is limited to the TCP event path, while release stores
  are only used when falling back to TCP. Other handshake-state accesses,
  including the completion hot path, use relaxed ordering to avoid
  unnecessary synchronization overhead.

• Breaking backward compatibility:

  None. This change does not modify any public API, wire protocol, or
  externally visible configuration.

[Copilot]

Pull request overview

This PR fixes a concurrency correctness issue in the RDMA transport handshake/fallback path by making the RDMA handshake state thread-safe and ensuring the TCP fallback state is published in a safe order, preventing TCP event handling from observing a partially published fallback.

Changes:

• Change rdma::RdmaEndpoint::_state from a plain enum to butil::atomic<State> to eliminate a C++ data race across handshake/TCP/completion paths.
• Reorder fallback publication in RdmaConnect::StartConnect() to set RdmaTransport::_rdma_state = RDMA_OFF before publishing RdmaEndpoint::_state = FALLBACK_TCP.
• Use a relaxed atomic load for the completion-path invariant check in RdmaEndpoint::HandleCompletion() to avoid adding unnecessary ordering overhead on a hot path.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/brpc/rdma/rdma_endpoint.h	Makes handshake state (_state) atomic to remove data races between concurrent RDMA/TCP/completion execution contexts.
src/brpc/rdma/rdma_endpoint.cpp	Fixes fallback publication ordering and updates the completion-path state check to use an explicit relaxed atomic load.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[chenBright]

When falling back to TCP, the require/release memory order is sufficient, and comments should be added. otherwise, use relaxed ordering.

[legionxiong]

When falling back to TCP, the require/release memory order is sufficient, and comments should be added. otherwise, use relaxed ordering.

Done.

[chenBright]

LGTM

[zyearn]

LGTM. Merging