The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
parallel.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: cb0816cdfd0f4438fbd3d25838d7879437a9d440 $
19 *
20 * @file unlang/parallel.c
21 * @brief Implementation of the unlang "parallel" keyword.
22 *
23 * @copyright 2006-2019 The FreeRADIUS server project
24 */
25
26
27RCSID("$Id: cb0816cdfd0f4438fbd3d25838d7879437a9d440 $")
28
29#include <freeradius-devel/server/rcode.h>
30#include <freeradius-devel/server/signal.h>
31#include <freeradius-devel/server/state.h>
32#include <freeradius-devel/server/request.h>
33#include <freeradius-devel/util/table.h>
34
35#include "action.h"
36#include "interpret.h"
37#include "mod_action.h"
38#include "subrequest.h"
39#include "interpret_priv.h"
40#include "unlang_priv.h"
41#include "parallel_priv.h"
42#include "child_request_priv.h"
43
44/** Cancel a specific child
45 *
46 * For most states we just change the current state to CANCELLED. For the RUNNABLE state
47 * we need to signal the child to cancel itself.
48 *
49 * We don't free any requests here, we just mark them up so their rcodes are ignored when
50 * the parent is resumed, the parent then frees the child, once we're sure its done being
51 * run through the intepreter.
52 */
53static inline CC_HINT(always_inline) void unlang_parallel_cancel_child(unlang_parallel_state_t *state, unlang_child_request_t *cr)
54{
55 request_t *child = cr->request;
56 request_t *request = child->parent; /* For debug messages */
57 unlang_child_request_state_t child_state = cr->state;
58
59 switch (cr->state) {
60 case CHILD_INIT:
62 fr_assert(!cr->request);
63 break;
64
65 case CHILD_EXITED:
66 cr->state = CHILD_CANCELLED; /* Don't process its return code */
67 break;
68
69 case CHILD_RUNNABLE: /* Don't check runnable_id, may be yielded */
70 /*
71 * Signal the child to stop
72 *
73 * The signal function cleans up the request
74 * and signals anything that was tracking it
75 * that it's now complete.
76 */
78
79 /*
80 * We don't free the request here, we wait
81 * until it signals us that it's done.
82 */
83 break;
84
85 case CHILD_DONE:
87 break;
88
89 case CHILD_DETACHED: /* Can't signal detached requests*/
90 fr_assert(!cr->request);
91 return;
92
93 case CHILD_CANCELLED:
94 break;
95
96 case CHILD_FREED:
97 return;
98 }
99
100 RDEBUG3("parallel - child %s (%d/%d) CANCELLED, previously %s",
101 cr->name, cr->num, state->num_children,
102 fr_table_str_by_value(unlang_child_states_table, child_state, "<INVALID>"));
103}
104
105/** Send a signal from parent request to all of it's children
106 *
107 */
109 unlang_stack_frame_t *frame, fr_signal_t action)
110{
111 unlang_parallel_state_t *state = talloc_get_type_abort(frame->state, unlang_parallel_state_t);
112 unsigned int i;
113
114 /*
115 * Signal any runnable children to get them to exit
116 */
117 if (action == FR_SIGNAL_CANCEL) {
118 for (i = 0; i < state->num_children; i++) unlang_parallel_cancel_child(state, &state->children[i]);
119
120 return;
121 }
122
123 /*
124 * Signal all of the runnable/running children.
125 */
126 for (i = 0; i < state->num_children; i++) {
127 if (state->children[i].state != CHILD_RUNNABLE) continue;
128
129 unlang_interpret_signal(state->children[i].request, action);
130 }
131}
132
133
135{
136 unlang_parallel_state_t *state = talloc_get_type_abort(frame->state, unlang_parallel_state_t);
137 unsigned int i;
138
139 fr_assert(state->num_runnable == 0);
140
141 for (i = 0; i < state->num_children; i++) {
142 unlang_child_request_t *cr = &state->children[i];
143
144 if (state->children[i].state != CHILD_EXITED) continue;
145
147
148 RDEBUG3("parallel - child %s (%d/%d) DONE",
149 state->children[i].name,
150 i + 1, state->num_children);
151
152 state->children[i].state = CHILD_DONE;
153
154 /*
155 * Return isn't allowed to make it back
156 * to the parent... Not sure this is
157 * the correct behaviour, but it's what
158 * was there before.
159 */
160 if (cr->result.priority == MOD_ACTION_RETURN) {
161 cr->result.priority = 0;
162 } else if (cr->result.priority == MOD_ACTION_REJECT) {
164 cr->result.priority = 0;
165 }
166
167 /*
168 * Do priority over-ride.
169 */
170 if (cr->result.priority > p_result->priority) {
171 RDEBUG4("** [%i] %s - overwriting existing result (%s %d) from higher priority to (%s %d)",
172 stack_depth_current(request), __FUNCTION__,
173 fr_table_str_by_value(mod_rcode_table, p_result->rcode, "<invalid>"),
174 p_result->priority,
176 cr->result.priority);
177 p_result->rcode = cr->result.rcode;
178 p_result->priority = cr->result.priority;
179 }
180 }
181
182 /*
183 * Reap the children....
184 */
185 for (i = 0; i < state->num_children; i++) {
186 if (!state->children[i].request) continue;
187
189
191
192 state->children[i].state = CHILD_FREED;
193 }
194
196}
197
199{
200 unlang_t const *instruction;
202 unlang_parallel_t *gext;
204
205 int i;
206
209
210 gext = unlang_group_to_parallel(g);
211
212 /*
213 * Allocate an array for the children.
214 */
215 MEM(frame->state = state = _talloc_zero_pooled_object(request,
217 (sizeof(state->children[0]) * g->num_children),
218 "unlang_parallel_state_t",
219 g->num_children,
220 (talloc_array_length(request->name) * 2)));
221 if (!state) {
222 return UNLANG_ACTION_FAIL;
223 }
224
225 (void) talloc_set_type(state, unlang_parallel_state_t);
226 state->result = RLM_MODULE_NOOP;
227 state->priority = MOD_ACTION_NOT_SET; /* as-yet unset */
228 state->detach = gext->detach;
229 state->clone = gext->clone;
230 state->num_children = g->num_children;
231
232 /*
233 * Initialize all of the children.
234 */
235 for (i = 0, instruction = g->children; instruction != NULL; i++, instruction = instruction->next) {
236 request_t *child;
237
238 child = unlang_io_subrequest_alloc(request,
239 request->proto_dict, state->detach);
240 child->packet->code = request->packet->code;
241
242 RDEBUG3("parallel - child %s (%d/%d) INIT",
243 child->name,
244 i + 1, state->num_children);
245
246 if (state->clone) {
247 /*
248 * Note that we do NOT copy the
249 * Session-State list! That
250 * contains state information for
251 * the parent.
252 */
253 if ((fr_pair_list_copy(child->request_ctx,
254 &child->request_pairs,
255 &request->request_pairs) < 0) ||
256 (fr_pair_list_copy(child->reply_ctx,
257 &child->reply_pairs,
258 &request->reply_pairs) < 0) ||
259 (fr_pair_list_copy(child->control_ctx,
260 &child->control_pairs,
261 &request->control_pairs) < 0)) {
262 REDEBUG("failed copying lists to child");
263 error:
264
265 /*
266 * Remove all previously
267 * spawned children.
268 */
269 for (--i; i >= 0; i--) {
271 state->children[i].state = CHILD_FREED;
272 }
273
274 return UNLANG_ACTION_FAIL;
275 }
276 }
277
278 /*
279 * Initialise our frame state, and push the first
280 * instruction onto the child's stack.
281 *
282 * This instruction will mark the parent as runnable
283 * when it is executed.
284 *
285 * We only do this if the requests aren't detached.
286 * If they are detached, this repeat function would
287 * be immediately disabled, so no point...
288 */
289 if (!state->detach) {
290 if (unlang_child_request_init(state, &state->children[i], child, NULL, &state->num_runnable,
291 frame_current(request)->instruction, false) < 0) goto error;
292 fr_assert(state->children[i].state == CHILD_INIT);
293 } else {
294 state->children[i].num = i;
295 state->children[i].request = child;
296 }
297
298 /*
299 * Push the first instruction for the child to run,
300 * which in case of parallel, is the child's
301 * subsection within the parallel block.
302 */
303 if (unlang_interpret_push(NULL, child,
304 instruction,
306 UNLANG_NEXT_STOP) < 0) goto error;
307 }
308
309 /*
310 * Now we're sure all the children are initialised
311 * start them running.
312 */
313 if (state->detach) {
314 for (i = 0; i < (int)state->num_children; i++) {
315 if (RDEBUG_ENABLED3) {
316 request_t *parent = request;
317
318 request = state->children[i].request;
319 RDEBUG3("parallel - child %s (%d/%d) DETACHED",
320 request->name,
321 i + 1, state->num_children);
322 request = parent;
323 }
324
325 /*
326 * Adds to the runnable queue
327 */
329
330 /*
331 * Converts to a detached request
332 */
334 }
335
336 /*
337 * We are now done, all the children are detached
338 * so we don't need to wait around for them to complete.
339 */
341 }
342
343 for (i = 0; i < (int)state->num_children; i++) {
344 /*
345 * Ensure we restore the session state information
346 * into the child.
347 */
348 if (state->children[i].config.session_unique_ptr) {
350 state->children[i].config.session_unique_ptr,
351 state->children[i].num);
352 }
353
354 /*
355 * Ensures the child is setup correctly and adds
356 * it into the runnable queue of whatever owns
357 * the interpreter.
358 */
360 state->children[i].state = CHILD_RUNNABLE;
361 }
362
363 /*
364 * Don't call this function again when the parent resumes,
365 * instead call a function to process the results
366 * of the children.
367 */
369
370 /*
371 * Yield to the children
372 *
373 * They scamper off to play on their own when they're all done,
374 * the last one tells the parent, so it can resume,
375 * and gather up the results, and mercilessly reap the children.
376 */
377 return UNLANG_ACTION_YIELD;
378}
379
Unlang interpreter actions.
unlang_action_t
Returned by unlang_op_t calls, determine the next action of the interpreter.
Definition action.h:35
@ UNLANG_ACTION_FAIL
Encountered an unexpected error.
Definition action.h:36
@ UNLANG_ACTION_CALCULATE_RESULT
Calculate a new section rlm_rcode_t value.
Definition action.h:37
@ UNLANG_ACTION_YIELD
Temporarily pause execution until an event occurs.
Definition action.h:41
#define RCSID(id)
Definition build.h:485
#define UNUSED
Definition build.h:317
fr_table_num_ordered_t const unlang_child_states_table[]
int unlang_child_request_init(TALLOC_CTX *ctx, unlang_child_request_t *out, request_t *child, unlang_result_t *p_result, unsigned int *sibling_count, void const *unique_session_ptr, bool free_child)
Initialize a child request.
struct unlang_child_request_t::@100 config
request_t * request
Child request. The actual request the child will run.
unlang_result_t result
The result of the child request.
char const * name
Cache the request name.
unlang_child_request_state_t state
State of the child.
unlang_child_request_state_t
Parallel child states.
@ CHILD_RUNNABLE
Running/runnable.
@ CHILD_DETACHED
Child has detached, we can't signal it or communicate with it anymore.
@ CHILD_INIT
Initial state, has no request allocated.
@ CHILD_EXITED
Child has run to completion, and is waiting to be reaped.
@ CHILD_CANCELLED
Child was cancelled.
@ CHILD_FREED
The child has been freed.
@ CHILD_DONE
The child has been processed by the parent the request should still exist, and should be freed.
int num
The child number.
Each child has a state, a number, a request, and a count of their siblings.
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:78
#define MEM(x)
Definition debug.h:36
bool unlang_request_is_scheduled(request_t const *request)
Return whether a request is currently scheduled.
Definition interpret.c:1569
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1396
int unlang_interpret_push(unlang_result_t *result_p, request_t *request, unlang_t const *instruction, unlang_frame_conf_t const *conf, bool do_next_sibling)
Push a new frame onto the stack.
Definition interpret.c:283
Declarations for the unlang interpreter.
unlang_mod_action_t priority
The priority or action for that rcode.
Definition interpret.h:136
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:153
#define UNLANG_SUB_FRAME
Definition interpret.h:37
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
#define UNLANG_TOP_FRAME
Definition interpret.h:36
Private declarations for the unlang interpreter.
static void interpret_child_init(request_t *request)
#define RDEBUG_ENABLED3
True if request debug level 1-3 messages are enabled.
Definition log.h:335
#define RDEBUG3(fmt,...)
Definition log.h:343
#define RDEBUG4(fmt,...)
Definition log.h:344
void unlang_register(int type, unlang_op_t *op)
Register an operation with the interpreter.
Definition base.c:63
request_t * unlang_io_subrequest_alloc(request_t *parent, fr_dict_t const *namespace, bool detachable)
Allocate a child request based on the parent.
Definition io.c:39
Unlang module actions.
@ MOD_ACTION_NOT_SET
Definition mod_action.h:40
@ MOD_ACTION_RETURN
Definition mod_action.h:43
@ MOD_ACTION_REJECT
Definition mod_action.h:42
int fr_pair_list_copy(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from)
Duplicate a list of pairs.
Definition pair.c:2320
void unlang_parallel_init(void)
Definition parallel.c:380
static unlang_action_t unlang_parallel(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Definition parallel.c:198
static void unlang_parallel_cancel_child(unlang_parallel_state_t *state, unlang_child_request_t *cr)
Cancel a specific child.
Definition parallel.c:53
static unlang_action_t unlang_parallel_resume(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Definition parallel.c:134
static void unlang_parallel_signal(UNUSED request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)
Send a signal from parent request to all of it's children.
Definition parallel.c:108
Declarations for the unlang "parallel" keyword.
bool detach
are we creating the child detached
static unlang_parallel_t * unlang_group_to_parallel(unlang_group_t *g)
Cast a group structure to the parallel keyword extension.
unsigned int num_runnable
How many children are complete.
bool clone
are the children cloned
bool detach
are we creating the child detached
unlang_child_request_t children[]
Array of children.
unsigned int num_children
How many children are executing.
#define fr_assert(_expr)
Definition rad_assert.h:38
#define REDEBUG(fmt,...)
Definition radclient.h:52
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:41
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:48
#define RETURN_UNLANG_NOOP
Definition rcode.h:63
#define REQUEST_VERIFY(_x)
Definition request.h:305
void fr_state_restore_to_child(request_t *child, void const *unique_ptr, int unique_int)
Restore subrequest data from a parent request.
Definition state.c:857
fr_signal_t
Signals that can be generated/processed by request signal handlers.
Definition signal.h:38
@ FR_SIGNAL_CANCEL
Request has been cancelled.
Definition signal.h:40
@ FR_SIGNAL_DETACH
Request is being detached from its parent.
Definition signal.h:45
void unlang_subrequest_detach_and_free(request_t **child)
Free a child request, detaching it from its parent and freeing allocated memory.
Definition subrequest.c:289
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
Private interpreter structures and functions.
unlang_t * next
Next node (executed on UNLANG_ACTION_EXECUTE_NEXT et al).
void * state
Stack frame specialisations.
#define UNLANG_NEXT_STOP
Definition unlang_priv.h:97
static unlang_group_t * unlang_generic_to_group(unlang_t const *p)
static unlang_stack_frame_t * frame_current(request_t *request)
static int stack_depth_current(request_t *request)
@ UNLANG_TYPE_PARALLEL
execute statements in parallel
Definition unlang_priv.h:53
static void frame_repeat(unlang_stack_frame_t *frame, unlang_process_t process)
Mark the current stack frame up for repeat, and set a new process function.
unlang_t const * instruction
The unlang node we're evaluating.
@ UNLANG_OP_FLAG_NO_FORCE_UNWIND
Must not be cancelled.
@ UNLANG_OP_FLAG_DEBUG_BRACES
Print debug braces.
@ UNLANG_OP_FLAG_RCODE_SET
Set request->rcode to the result of this operation.
unlang_t * children
Children beneath this group.
Generic representation of a grouping.
An unlang operation.
A node in a graph of unlang_op_t (s) that we execute.
Our interpreter stack, as distinct from the C stack.
static fr_slen_t parent
Definition pair.h:839