![]() |
The FreeRADIUS server $Id: a4e7f8c94e8038b7627bcf52356b7ed15955c1d7 $
|
Two-way thread-safe channels. More...
#include <freeradius-devel/io/channel.h>#include <freeradius-devel/util/debug.h>#include <freeradius-devel/util/stdatomic.h>
Include dependency graph for channel.c:Go to the source code of this file.
Data Structures | |
| struct | fr_channel_control_t |
| The payload of every channel control message. More... | |
| struct | fr_channel_end_t |
| One end of a channel. More... | |
| struct | fr_channel_hooks_t |
| The callbacks one control plane's owner registered for channel events. More... | |
| struct | fr_channel_s |
| A full channel, which consists of two ends. More... | |
Macros | |
| #define | ATOMIC_QUEUE_SIZE (1024) |
| Size of the atomic queues. | |
| #define | IALPHA (8) |
| #define | MPRINT(...) |
| #define | RTT(_old, _new) fr_time_delta_wrap((fr_time_delta_unwrap(_new) + (fr_time_delta_unwrap(_old) * (IALPHA - 1))) / IALPHA) |
Typedefs | |
| typedef struct fr_channel_s | fr_channel_t |
Enumerations | |
| enum | fr_channel_direction_t : uint8_t { TO_RESPONDER = 0 , TO_REQUESTOR = 1 } |
Functions | |
| static void | channel_close (void const *data, size_t data_size, fr_time_t now, void *uctx) |
| The requestor is closing a channel to us. | |
| static void | channel_close_ack (void const *data, size_t data_size, fr_time_t now, void *uctx) |
| The responder has finished closing a channel we asked it to close. | |
| static void | channel_data_done_responder (void const *data, size_t data_size, fr_time_t now, void *uctx) |
| The responder has serviced its requests, and says how many it has seen. | |
| static void | channel_data_to_requestor (void const *data, size_t data_size, UNUSED fr_time_t now, void *uctx) |
| The responder has queued replies for the requestor. | |
| static void | channel_data_to_responder (void const *data, size_t data_size, UNUSED fr_time_t now, void *uctx) |
| The requestor has queued requests for the responder. | |
| static void | channel_drain_replies (fr_channel_t *ch) |
| Drain the replies queued for the requestor. | |
| static void | channel_drain_requests (fr_channel_t *ch) |
| Drain the requests queued for the responder. | |
| static void | channel_message_unpack (fr_channel_control_t *cc, void const *data, NDEBUG_UNUSED size_t data_size) |
| Unpack the payload of a channel control message. | |
| static void | channel_open (void const *data, size_t data_size, fr_time_t now, void *uctx) |
| A requestor has opened a channel to us. | |
| bool | fr_channel_active (fr_channel_t *ch) |
| Check if a channel is active. | |
| int | fr_channel_callbacks_add (fr_control_t *c, fr_channel_callbacks_t const *callbacks, void *uctx) |
| Register the owner's channel callbacks on its control plane. | |
| fr_channel_t * | fr_channel_create (TALLOC_CTX *ctx, fr_control_t *requestor, fr_control_t *responder, bool same) |
| Create a new channel. | |
| static int | fr_channel_data_ready (fr_channel_t *ch, fr_time_t when, fr_channel_end_t *end, fr_channel_control_event_t ev) |
| Send a message via a kq user signal. | |
| int | fr_channel_null_reply (fr_channel_t *ch) |
| Don't send a reply message into the channel. | |
| bool | fr_channel_recv_reply (fr_channel_t *ch) |
| Receive a reply message from the channel. | |
| bool | fr_channel_recv_request (fr_channel_t *ch) |
| Receive a request message from the channel. | |
| fr_channel_stats_t const * | fr_channel_requestor_stats (fr_channel_t const *ch) |
| Statistics for the requestor's end of a channel. | |
| void | fr_channel_requestor_uctx_add (fr_channel_t *ch, void *uctx) |
| Add network-specific data to a channel. | |
| void * | fr_channel_requestor_uctx_get (fr_channel_t *ch) |
| Get network-specific data from a channel. | |
| int | fr_channel_responder_ack_close (fr_channel_t *ch) |
| Acknowledge that the channel is closing. | |
| unsigned int | fr_channel_responder_discard (fr_channel_t *ch) |
| Discard any requests the requestor queued but we never received. | |
| fr_channel_stats_t const * | fr_channel_responder_stats (fr_channel_t const *ch) |
| Statistics for the responder's end of a channel. | |
| void | fr_channel_responder_uctx_add (fr_channel_t *ch, void *uctx) |
| Add responder-specific data to a channel. | |
| void * | fr_channel_responder_uctx_get (fr_channel_t *ch) |
| Get responder-specific data from a channel. | |
| int | fr_channel_send_reply (fr_channel_t *ch, fr_channel_data_t *cd) |
| Send a reply message into the channel. | |
| int | fr_channel_send_request (fr_channel_t *ch, fr_channel_data_t *cd) |
| Send a request message into the channel. | |
| int | fr_channel_service_kevent (fr_channel_t *ch, fr_control_t *c, UNUSED struct kevent const *kev) |
| Service a control-plane event. | |
| int | fr_channel_set_recv_reply (fr_channel_t *ch, fr_channel_recv_callback_t recv_reply, void *uctx) |
| int | fr_channel_set_recv_request (fr_channel_t *ch, fr_channel_recv_callback_t recv_request, void *uctx) |
| int | fr_channel_signal_open (fr_channel_t *ch, fr_message_set_t *reply_ms) |
| Send a channel to a responder. | |
| int | fr_channel_signal_responder_close (fr_channel_t *ch) |
| Signal a responder that the channel is closing. | |
| void | fr_channel_stats_log (fr_channel_t const *ch, fr_log_t const *log, char const *file, int line) |
Two-way thread-safe channels.
Definition in file channel.c.
| struct fr_channel_control_t |
The payload of every channel control message.
Which event it is comes from the control message, not from the payload.
Collaboration diagram for fr_channel_control_t:| Data Fields | ||
|---|---|---|
| uint64_t | ack | the sender's ack sequence, for data done. |
| fr_channel_t * | ch | the channel |
| fr_message_set_t * | reply_ms | the reply message set, for open only. |
| struct fr_channel_end_t |
One end of a channel.
Consists of a kqueue descriptor, and an atomic queue. The atomic queue is there to get bulk data through, because it's more efficient than pushing 1M+ events per second through a kqueue.
Collaboration diagram for fr_channel_end_t:| Data Fields | ||
|---|---|---|
| uint64_t | ack | Sequence number of the other end. |
| atomic_bool | active | Whether the channel is active. |
| fr_atomic_queue_t * | aq | The queue of messages - visible only to this channel. |
| fr_control_t * | control | The control plane we signal this end through. |
| fr_channel_direction_t | direction | Use for debug messages. |
| fr_channel_recv_callback_t | recv | callback for receiving messages |
| void * | recv_uctx | context for receiving messages |
| uint64_t | sequence | Sequence number for this channel. |
| uint64_t | sequence_at_last_signal | When we last signaled. |
| fr_channel_stats_t | stats | channel statistics |
| uint64_t | their_view_of_my_sequence | Should be clear. |
| void * | uctx | Worker context. |
| struct fr_channel_hooks_t |
The callbacks one control plane's owner registered for channel events.
Collaboration diagram for fr_channel_hooks_t:| Data Fields | ||
|---|---|---|
| fr_channel_callbacks_t | cb | what the owner does with each event |
| fr_control_t * | control | the control plane these were registered on |
| void * | uctx | passed to each callback |
| struct fr_channel_s |
A full channel, which consists of two ends.
A channel consists of an I/O identifier that can be placed in kequeue and an atomic queue in each direction to allow for bidirectional communication.
Collaboration diagram for fr_channel_s:| Data Fields | ||
|---|---|---|
| fr_time_delta_t | cpu_time | Total time used by the responder for this channel. |
| fr_channel_end_t | end[2] | Two ends of the channel. |
| fr_time_delta_t | processing_time | Time spent by the responder processing requests. |
| bool | same_thread | are both ends in the same thread? |
| #define ATOMIC_QUEUE_SIZE (1024) |
Size of the atomic queues.
The queue reader MUST service the queue occasionally, otherwise the writer will not be able to write. If it's too low, the writer will fail. If it's too high, it will unnecessarily use memory. So we're better off putting it on the high side.
The reader SHOULD service the queues at inter-packet latency. i.e. at 1M pps, the queue will get serviced every microsecond.
| #define RTT | ( | _old, | |
| _new | |||
| ) | fr_time_delta_wrap((fr_time_delta_unwrap(_new) + (fr_time_delta_unwrap(_old) * (IALPHA - 1))) / IALPHA) |
| typedef struct fr_channel_s fr_channel_t |
| enum fr_channel_direction_t : uint8_t |
|
static |
The responder has serviced its requests, and says how many it has seen.
Only sent by the responder. Replies may be waiting, so drain them. First compare their ACK to the last sequence we sent, and if they have not seen our latest, signal the responder to wake up.
Definition at line 671 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:
|
inlinestatic |
Drain the replies queued for the requestor.
Runs on the requestor's thread, see channel_drain_requests().
Definition at line 624 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:
|
inlinestatic |
Drain the requests queued for the responder.
Runs on the responder's thread, so a signal which finds nothing is counted in the responder's own stats. Each end's stats are only ever written by that end's thread.
Definition at line 611 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:
|
inlinestatic |
| bool fr_channel_active | ( | fr_channel_t * | ch | ) |
Check if a channel is active.
A channel may be closed by either end. If so, it stays alive (but inactive) until both ends acknowledge the close.
| [in] | ch | the channel |
Definition at line 850 of file channel.c.
Here is the caller graph for this function:| int fr_channel_callbacks_add | ( | fr_control_t * | c, |
| fr_channel_callbacks_t const * | callbacks, | ||
| void * | uctx | ||
| ) |
Register the owner's channel callbacks on its control plane.
Call before fr_control_open(). Every channel event gets its own entry in the FR_CONTROL_EVENTSET_CHANNEL event set, so the control plane dispatches straight to the handler for that event.
| [in] | c | the control plane channels will signal. |
| [in] | callbacks | what the owner does with each event. Copied. |
| [in] | uctx | passed to each callback. |
Definition at line 784 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:| fr_channel_t * fr_channel_create | ( | TALLOC_CTX * | ctx, |
| fr_control_t * | requestor, | ||
| fr_control_t * | responder, | ||
| bool | same | ||
| ) |
Create a new channel.
| [in] | ctx | The talloc_ctx to allocate channel data in. |
| [in] | requestor | control plane. |
| [in] | responder | control plane. |
| [in] | same | whether or not the channel is for the same thread |
Definition at line 167 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:
|
static |
Send a message via a kq user signal.
Note that the caller doesn't care about data in the event, that is sent via the atomic queue. The kevent code takes care of delivering the signal once, even if it's sent by multiple requestor threads.
The thread watching the KQ knows which end it is. So when it gets the signal (and the channel pointer) it knows to look at end[0] or end[1]. We also send which end in 'which' (0, 1) to further help the recipient.
| [in] | ch | the channel. |
| [in] | when | the data was ready. Typically taken from the message. |
| [in] | end | of the channel that the message was written to. |
| [in] | ev | the event to send. |
Definition at line 238 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:| int fr_channel_null_reply | ( | fr_channel_t * | ch | ) |
| bool fr_channel_recv_reply | ( | fr_channel_t * | ch | ) |
| bool fr_channel_recv_request | ( | fr_channel_t * | ch | ) |
| fr_channel_stats_t const * fr_channel_requestor_stats | ( | fr_channel_t const * | ch | ) |
| void fr_channel_requestor_uctx_add | ( | fr_channel_t * | ch, |
| void * | uctx | ||
| ) |
| void * fr_channel_requestor_uctx_get | ( | fr_channel_t * | ch | ) |
| int fr_channel_responder_ack_close | ( | fr_channel_t * | ch | ) |
| unsigned int fr_channel_responder_discard | ( | fr_channel_t * | ch | ) |
Discard any requests the requestor queued but we never received.
The messages belong to the requestor's message set, and it cannot reclaim them until they are marked done. A responder that closes with requests still in the queue would strand them there, and with them the memory they were allocated from.
| [in] | ch | to discard the queued requests of. |
Definition at line 895 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:| fr_channel_stats_t const * fr_channel_responder_stats | ( | fr_channel_t const * | ch | ) |
| void fr_channel_responder_uctx_add | ( | fr_channel_t * | ch, |
| void * | uctx | ||
| ) |
| void * fr_channel_responder_uctx_get | ( | fr_channel_t * | ch | ) |
| int fr_channel_send_reply | ( | fr_channel_t * | ch, |
| fr_channel_data_t * | cd | ||
| ) |
Send a reply message into the channel.
The message should be initialized, other than "sequence" and "ack".
| [in] | ch | the channel to send the reply on. |
| [in] | cd | the message to send |
Definition at line 457 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:| int fr_channel_send_request | ( | fr_channel_t * | ch, |
| fr_channel_data_t * | cd | ||
| ) |
Send a request message into the channel.
The message should be initialized, other than "sequence" and "ack".
This function automatically calls the recv_reply callback if there is a reply.
| [in] | ch | the channel to send the request on. |
| [in] | cd | the message to send. |
Definition at line 271 of file channel.c.
Here is the call graph for this function:
Here is the caller graph for this function:| int fr_channel_service_kevent | ( | fr_channel_t * | ch, |
| fr_control_t * | c, | ||
| UNUSED struct kevent const * | kev | ||
| ) |
Service a control-plane event.
The channels use control planes for internal signaling. Note that the caller does NOT pass the channel into this function. Instead, the channel is taken from the kevent.
| [in] | ch | The channel to service. |
| [in] | c | The control plane on which we received the kev. |
| [in] | kev | The kevent data, should get passed to the control plane. |
Definition at line 826 of file channel.c.
Here is the caller graph for this function:| int fr_channel_set_recv_reply | ( | fr_channel_t * | ch, |
| fr_channel_recv_callback_t | recv_reply, | ||
| void * | uctx | ||
| ) |
| int fr_channel_set_recv_request | ( | fr_channel_t * | ch, |
| fr_channel_recv_callback_t | recv_request, | ||
| void * | uctx | ||
| ) |
| int fr_channel_signal_open | ( | fr_channel_t * | ch, |
| fr_message_set_t * | reply_ms | ||
| ) |
| int fr_channel_signal_responder_close | ( | fr_channel_t * | ch | ) |
| void fr_channel_stats_log | ( | fr_channel_t const * | ch, |
| fr_log_t const * | log, | ||
| char const * | file, | ||
| int | line | ||
| ) |
| fr_table_num_sorted_t const channel_packet_priority[] |
| size_t channel_packet_priority_len = NUM_ELEMENTS(channel_packet_priority) |
| fr_table_num_sorted_t const channel_signals[] |
| size_t channel_signals_len = NUM_ELEMENTS(channel_signals) |
1.9.8