Add a deferred signal handling system to the connection API

It was a nightmare trying to reason about how signals would be delivered to the connections from within the handlers, so prevent that from happening, EVER.

Now the connection state machine completes whatever work it needs to, then at the end, checks to see if the handlers signalled it, and THEN, AND ONLY THEN does it process the signals.

The signals run through the public signalling interface, which should mean the connection is never allowed to make an invalid transition.  Signals that are invalid for the connections current state are just ignored.

reuse more memory

Make JIT stack size configurable, and keep the stack sizes consistent between library versions

Add missing errors, increase JIT stack size

increase size of output buffer

Revert "use PCRE function to get error string"

This reverts commit 278ba5cdf353739bfdef5a9b20836430c5affd3e.

Nope.

use PCRE function to get error string

Better tracking for stacked handlers in connection.c

They don't really do much here, but it allows us to prevent certain signalling functions being used in handlers in future.

Move to macros for all request list changes

Typo

Everywhere else uses entry as the dlist fields

Add shutdown callback to the redis handle

Deal with return codes from the shutdown callback

Used

Fix LDAP connection callback

Add support for shutting down connections gracefully

Update Pica8 dictionary

Start of Redis Async I/O tests

Get basic Redis async I/O functional

Only two packets

Remove duplicate message

Typo

Always need to add the linking context

Add function to check if a list is initialised

Add notes on heap allocations

Fix linker args

Fix test command output for the EAP tests

Implement self-contained way of managing the request slab allocator

There's no real reason to use specific free lists.  We want all requests in a particular thread to be allocated in the same list, and passing around free list heads just makes things more complicated.

This seems to deal ok with child requests too.

Revert "alloc / free requests into worker-specific list"

This reverts commit dd4dcaeccfe4334e0d45f08549b070ae98dad314.

Revert "add APIs to mark a request as unused, or to re-use a request"

This reverts commit de712c55940c3b2aa8bec49ae93b1c4aa62ffb14.

s/rad_request/fr_request_s/

point to "track" and not "entry"

alloc / free requests into worker-specific list

use new API for fr_dict_enum_by_value()

use new API for fr_dict_enum_by_value()

add duplicate of fr_dict_enum_by_value(), which takes dict

that saves rather surprising amounts of time.

add APIs to mark a request as unused, or to re-use a request

this avoids the malloc / free loop when dealing with large
volumes of requests

add API to clear request_data

add API to clear a pre-existing stack

test result of write()

need this, too

remove test which no longer works

call event timer delete instead of const_free

which lets us re-use the timer event

slab allocator && re-use for tracking structures

which saves ~1/2s on a ~20s run.

initialize variable to quiet stupid scanner

All todos done...

Unused arg

move control API to pipes instead of poking kevent.

it's a LOT faster to signal via pipes & kevent than to add / delete
individual kevents

check for debug BEFORE calling debug function

map_list_mod_debug() does a lot of unconditional allocations.
So don't call it unless we know it's debugging

call fr_worker_verify only when WITH_VERIFY_PTR is set

Typo

Add dumb script to run the google profiler against a binary

Support connection lifetime

Test high/low edges for connection spawning

Check the callbacks were actually called in the I/O tests

Set start time to 1, so we don't trigger asserts

Typo

Notes on what we're doing in trunk_requests_per_connection

Increase debug priority of trunk connection state changes

We should only see these printed once a steady state has been reached if something genuinely interesting happens, like a load spike or network disruption

Add draining_to_free state to simplify max_uses and lifetime

Connections in the draining-to-free state cannot be reactivated, and will be freed once there are no more requests associated with them.

Connections in the draining state can be reactivated if we get a load spike

Fix issues with freeing requests

Implement max_uses

Add configuration parser

add simple profiling make file

so that mere mortals can run the profiling tools

make sure that each packet has it's own unique time

Fix redefinition

Formatting

Always include autoconf.h in talloc.h

When doing standalone builds it's easy to miss the include for autoconf.h and it leads to stupid things

Insert freed requests into an unassigned list, ready to be used again

This gives us significant performance improvements (as you'd expect)

Space to tabs

stupid integer overflow

add todo note

limit to max backlog

Unused

Remove and rename fields

Fix opening connection in the connection manager

Rebalance the backlogs of connections when a new connection becomes active

We only need to update trunk I/O events on connection state changes if the connection was just closed

We'll add I/O events back if new requests are enqueued

Call cancel_mux if there's partial cancellations too

Only enforce max_connections if its above zero

Start off assuming we're probably above our target number of connections

s/waited/elapsed

Doxygen

Cancel sent can be entered from cancel_partial

Expose interface to requeue requests

Call the cancel callback after the request has changed state

Recalculate requests per connection when a request enters the backlog

Formatting

Assert if the connection is not in the correct state when CONN_REORDER is called

Skip reordering if we only have one connection

Print connection numbers in debug output

Rename request/connection counting functions to have consistent names

Allow immediate spawning of connections

Unused fields

Move tests into a separate file

send packets on reply only if we missed packets

and don't send any packets if we're gated.

This keeps the backlog correct.  But it still sends at a rate
higher than the requested PPS.  It's not yet clear why that's happening

skip timer if we are not getting a response

correct output stats

always run the timer at expected intervals

manual merge from v3.0.x

fix error messages

Fix rlm_python build with Python 3.6.x

We don't need '-Wl,-stack_size,1000000'

Add more debug info when tracing connectoin.c function calls

Rename FULL to INACTIVE

It's essentially the same state.  The connection should not have any new requests queued up, but is free to continue processing existing ones.

We should probably add a public API function to shift requests off a particular connection too.

notes for TLVs

typo

vim being "helpful"...