PFCP async mode + coarse procedure gate (Gy update_credits pilot)

[next-nf]

Step 2 of the non-blocking context I/O work. Stacked on #45 (async_m foundation) — base branch is async-m-step1, so this PR's diff is only the step-2 changes. Review/merge #45 first.

Makes mid-session PFCP non-blocking, and proves it by converting one pilot procedure — the Gy update_credits → session_modification handler — off the blocking gen_statem:call. Everything except the pilot is behavior-preserving.

What's here

• Async PFCP transport — smf_sx_node:send_request/2 (mirrors call/2, mints a request id, delivers the reply as {'$async_reply', ReqId, Reply} reusing async_m monad + driver: non-blocking context I/O foundation #45's info clause; socket untouched) + smf_pfcp_context:modify_session_async/5 and a pure modify_session_result/2 decoder. Fixes a latent bug for free: the old gen_statem:call/2 used the 5s OTP default while the socket retries ~180s, so the context could exit(timeout) before the UPF answered.
• Coarse procedure gate — while a PFCP procedure is in flight (async_pending non-empty), a gate field in the FSM state is busy and procedure-initiating events are postponed; the busy→idle flip on drain re-fires them. This reproduces today's one-procedure-at-a-time serialization non-blockingly (so a reentrant RAR/report is serviced during the await instead of deadlocking). Gated set: GTP requests, the internal update_credits event, and gx/gy RAR/ASR/pfcp_timer (all of which mutate the shared PCtx). Coarse first; a later step refines toward per-resource concurrency and answer-RAA-immediately-queue-the-procedure.
• Pilot conversion — update_credits becomes a linear do([async_m || …]) procedure (issue → await → resume). The old throw-based error smuggling is dropped: the monad hands the error handler live Data, so handle_ctx_error/4 reads context from there.

Why the gate is mandatory

Every PFCP procedure threads the shared session PCtx. Two PFCP-touching procedures can't overlap — a second one reading PCtx at issue time, before the first's resume writes back, loses the update. The old blocking code enforced this implicitly; going async requires the gate to keep it.

Tests

• smf_pfcp_context_SUITE (decode) and gtp_context_gate_SUITE (pure gate logic) — 9/9.
• Three pgw_SUITE cases over the simulated UPF: async round-trip, gate-serializes-a-second-procedure (holding the reply via smf_test_sx_up:disable), and reentrancy-during-await.
• Full pgw_SUITE 127/127 (124 + 3); default-profile rebar3 compile green.

Review outcome

Whole-branch review returned YES-with-fixes; all Important findings fixed in this branch: gate now covers RAR/ASR/timer (closing a real serialization regression), and the disable-based tests have failure-safe teardown. Two Minors deferred as non-bugs: an error-semantics improvement on an untested branch, and resume-re-park gate-wrapping that only matters for future multi-await procedures.

🤖 Generated with Claude Code

[next-nf]

this could is a cut

[next-nf]

Done: async_m:modify_data(_#{pfcp => PCtx, pcc => PCC}) — verified it compiles and runs (erlando cut scopes to the map-update, not the enclosing call) (3c39802).

[next-nf]

can't these be merged into a single line?

[next-nf]

Merged: #{pfcp := PCtx0, bearers := BearerMap, pcc := PCC0} <- async_m:get_data() (3c39802).

[next-nf]

single line merge?

[next-nf]

Merged: {PCtx, _, _} <- await_modify(Issued) (3c39802).

[next-nf]

Why is it necessary to copy the gate state into the FSM state? The gate check above could instead access async_pending directly, coulnd't it?

[next-nf]

Removed. There is no gate field anymore — gate_result/3, gate_of/1 and run_gated/5 are gone. With async_pending in the State map (PR #45), the gate clauses read it directly and the park/drain of the registry is itself the state-term change that re-fires postponed events, so nothing is copied (3c39802).

[next-nf]

Suggested change

	handle_event(internal, {session, {update_credits, _}, _}, #{gate := busy}, _Data) ->
	handle_event(internal, {session, {update_credits, _}, _}, #{async_pending := AsyncP}, _Data) whem map_size(AsyncP) /= 0 ->

Note: putting async_pending into data instead of putting into state seems to be a mistake in the async PR.

[next-nf]

Done. Moved the async_pending registry from Data into the gen_statem State (PR #45, 84eed78) so mutating it is a state-term change — which is what makes gen_statem re-deliver postponed events. The gate now guards on it directly instead of a copied flag: #{async_pending := P}, _Data) when map_size(P) =/= 0 -> {keep_state_and_data, [postpone]} (3c39802).