1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
//! EPICS `libCom` for Rust: the layer an IOC is built *on*, with no record
//! system above it.
//!
//! This is `epics_base_rs::runtime` and `epics_base_rs::net` lifted out of
//! `epics-base-rs` (issue #55) so a consumer — a protocol client, a gateway,
//! `pvxs-rs` — can take the concurrency and socket primitives without taking
//! the database with them. The name is C's: `libCom` is where upstream EPICS
//! keeps `epicsThread`, `epicsTime`, `errlog`, `envDefs` *and* `osiSock`, which
//! is exactly this crate's two modules.
//!
//! `epics-base-rs` re-exports both modules at their original paths, so
//! `epics_base_rs::runtime::…` and `epics_base_rs::net::…` still resolve and
//! nothing downstream had to change.
//!
//! * [`runtime`] — the task seam and its two backends, `epicsThread`-parity
//! priority bands, `errlog`, the EPICS string/environment types, the
//! general-time provider.
//! * [`net`] — the EPICS protocols' shared socket layer: per-NIC async UDP,
//! interface enumeration, loopback multicast. Host-only; the wire constants
//! beside it compile for every target, RTEMS included.
//! * [`walltime`] — [`WallTime`](walltime::WallTime), the wall-clock instant
//! `runtime::time` returns. It lived in `epics_base_rs::types` and moved down
//! with its producer; `epics-base-rs` re-exports it at `types::WallTime`.
//!
//! # Features
//!
//! * `rtems-exec-model` — select the reactor-free `exec_backend` on a hosted
//! target. See [`EXEC_BACKEND`].
//! * `linux-rt` — back [`runtime::sync::PriorityInheritanceMutex`] with a
//! `PTHREAD_PRIO_INHERIT` `pthread_mutex_t` on Linux.
// The three `epics-base-rs` crate-level allows this code was written under and
// still needs — `collapsible_if` and `manual_range_contains` in `runtime`,
// `io_other_error` in `net`. Narrowed to those three rather than inherited
// wholesale: the extraction is a move, so the code is byte-identical and a
// lint it does not trip has no business being silenced here.
// The exec backend's blocking pumps end a parked reader with a local
// `shutdown(Shutdown::Both)` and bound a stuck writer through loopback
// send-backpressure (`runtime::blocking_io`). Both are POSIX blocking-socket
// semantics; Windows provides neither (measured, PR #56 CI 2026-07-24: a
// parked `recv` outlived shutdown by the full 120 s test bound, and an
// 8 MiB frame to a never-reading peer was swallowed in 12 ms), so a Windows
// build selecting this backend would hang on connection teardown instead of
// failing visibly. Refuse it at compile time rather than ship that.
compile_error!;
// Lets `#[epics_macros_rs::epics_test]` expansions — which name the runtime
// crate by its external path — resolve inside this crate's own unit tests,
// where proc-macro-crate reports `FoundCrate::Itself`. Same device as
// `epics-base-rs`'s alias for the same macro.
extern crate self as epics_libcom_rs;
/// Which [`runtime::task`] backend this build selected — `true` for the
/// reactor-free std-thread [`runtime::background`] executor, `false` for tokio.
///
/// The predicate is computed once, in this crate's `build.rs`, from the target
/// OS and the `rtems-exec-model` feature. A crate above that derives the same
/// `cfg` from its own `build.rs` (`epics-base-rs` does, for `server::scan`)
/// can pin the two together with a `const _: () = assert!(...)`, so a feature
/// forward that stops being wired fails to compile instead of splitting the
/// workspace across two backends.
pub const EXEC_BACKEND: bool = cfg!;