request->priority and request->sequence are no longer just used by the IO code, and...

diff --git a/src/lib/io/listen.h b/src/lib/io/listen.h
index b75586f50a3e795edadbc6dac5837b1c8408d907..d5441c9d83d4f1a139e7c8ede08dc3a905d3464f 100644 (file)
--- a/src/lib/io/listen.h
+++ b/src/lib/io/listen.h
@@ -68,9 +68,6 @@ struct fr_async_s {
        void                    *packet_ctx;
        fr_listen_t             *listen;        //!< How we received this request,
                                                //!< and how we'll send the reply.
-       uint32_t                priority;       //!< higher == higher priority
-
-       uint32_t                sequence;       //!< higher == higher priority, too
 };
 
 int fr_io_listen_free(fr_listen_t *li);

diff --git a/src/lib/io/worker.c b/src/lib/io/worker.c
index 05bca03d4e15a1eed7b2873d3279d6e926a01da3..bd0caa937f57a0487235501e4487264f73044333 100644 (file)
--- a/src/lib/io/worker.c
+++ b/src/lib/io/worker.c
@@ -866,7 +866,7 @@ static void worker_request_bootstrap(fr_worker_t *worker, fr_channel_data_t *cd,
 
        request->async->listen = listen;
        request->async->packet_ctx = cd->packet_ctx;
-       request->async->priority = cd->priority;
+       request->priority = cd->priority;
 
        /*
         *      Now that the "request" structure has been initialized, go decode the packet.
@@ -994,10 +994,10 @@ static int8_t worker_runnable_cmp(void const *one, void const *two)
        request_t const *a = one, *b = two;
        int ret;
 
-       ret = CMP(b->async->priority, a->async->priority);
+       ret = CMP(b->priority, a->priority);
        if (ret != 0) return ret;
 
-       ret = CMP(a->async->sequence, b->async->sequence);
+       ret = CMP(a->sequence, b->sequence);
        if (ret != 0) return ret;
 
        return fr_time_cmp(a->async->recv_time, b->async->recv_time);

diff --git a/src/lib/server/request.h b/src/lib/server/request.h
index dbf1d53798f0d73e01928c3b207004aeb0efc8ca..8f077da529b71201adfb9a483fa3e426c60a4a64 100644 (file)
--- a/src/lib/server/request.h
+++ b/src/lib/server/request.h
@@ -273,6 +273,10 @@ struct request_s {
        int                     alloc_line;     //!< Line the request was allocated on.
 
        fr_dlist_t              listen_entry;   //!< request's entry in the list for this listener / socket
+
+       uint32_t                priority;       //!< higher == higher priority
+       uint32_t                sequence;       //!< higher == higher priority, too
+
        fr_heap_index_t         runnable;       //!< entry in the heap of runnable packets
 
 };                             /* request_t typedef */

diff --git a/src/lib/server/state.c b/src/lib/server/state.c
index 84ceedd69dfb6fed073d355e0950a215c4846b5b..011ad1d65b96835e85061cc0fef30d68ee2995b8 100644 (file)
--- a/src/lib/server/state.c
+++ b/src/lib/server/state.c
@@ -720,7 +720,7 @@ int fr_state_to_request(fr_state_tree_t *state, request_t *request)
        /*
         *      Set sequence so that we can prioritize ongoing multi-packet sessions.
         */
-       request->async->sequence = entry->tries;
+       request->sequence = entry->tries;
        REQUEST_VERIFY(request);
        return 0;
 }

diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index 589ea3a1289d0a284724e9cd4791cd7f1ffe374a..4861e250b05bf619fd5b16659aff5f177231cae1 100644 (file)
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -1299,7 +1299,7 @@ void unlang_interpret_request_prioritise(request_t *request, uint32_t priority)
 
        intp = stack->intp;
 
-       request->async->priority = priority;
+       request->priority = priority;
 
        if (intp->funcs.prioritise) intp->funcs.prioritise(request, intp->uctx);
 }
@@ -1477,8 +1477,7 @@ static void instruction_retry_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time
 
 static void instruction_timeout_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
 {
-       unlang_retry_t                  *retry = talloc_get_type_abort(ctx, unlang_retry_t);
-       request_t                       *request = talloc_get_type_abort(retry->request, request_t);
+       request_t                       *request = talloc_get_type_abort(ctx, request_t);
 
        RDEBUG("Maximum timeout reached, signalling interpreter to stop the request.");
 

diff --git a/src/listen/radius/proto_radius.c b/src/listen/radius/proto_radius.c
index 46aa9ada19e1852c7c929762a2f93f0d1a58d302..cea58bbfaedd1b327428a7edf90913b74ec88a59 100644 (file)
--- a/src/listen/radius/proto_radius.c
+++ b/src/listen/radius/proto_radius.c
@@ -406,7 +406,7 @@ static int mod_decode(void const *instance, request_t *request, uint8_t *const d
         */
        if ((request->packet->code == FR_RADIUS_CODE_ACCESS_REQUEST) &&
            fr_pair_find_by_da(&request->request_pairs, NULL, attr_state)) {
-               request->async->sequence = 1;
+               request->sequence = 1;
        }
 
        if (fr_packet_pairs_from_packet(request->request_ctx, &request->request_pairs, request->packet) < 0) {

diff --git a/src/modules/rlm_radius/bio.c b/src/modules/rlm_radius/bio.c
index b5a38a6a69a6f280b4c9d8a68d9d80d1e0c3c499..1f8fdfb7af86205d07f804de194f1c1ce27b3da8 100644 (file)
--- a/src/modules/rlm_radius/bio.c
+++ b/src/modules/rlm_radius/bio.c
@@ -2413,7 +2413,7 @@ static int mod_enqueue(bio_request_t **p_u, fr_retry_config_t const **p_retry_co
         *      Can't use compound literal - const issues.
         */
        u->code = request->packet->code;
-       u->priority = request->async->priority;
+       u->priority = request->priority;
        u->recv_time = request->async->recv_time;
        fr_pair_list_init(&u->extra);
 

diff --git a/src/modules/rlm_tacacs/rlm_tacacs_tcp.c b/src/modules/rlm_tacacs/rlm_tacacs_tcp.c
index b76307db3b520a25c2562cf3485b75f9e3f2c841..ebc58cfccd4fdc0b324ff595a2bc213a21d2926a 100644 (file)
--- a/src/modules/rlm_tacacs/rlm_tacacs_tcp.c
+++ b/src/modules/rlm_tacacs/rlm_tacacs_tcp.c
@@ -1392,7 +1392,7 @@ static unlang_action_t mod_enqueue(unlang_result_t *p_result, void **rctx_out, U
         */
        MEM(u = talloc_zero(treq, udp_request_t));
        u->code = request->packet->code;
-       u->priority = request->async->priority;
+       u->priority = request->priority;
        u->recv_time = request->async->recv_time;
 
        r->rcode = RLM_MODULE_FAIL;