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: 05b0d28fec3bd95e17224e99c8e2107a444d09cd $
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: 05b0d28fec3bd95e17224e99c8e2107a444d09cd $")
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 * Over-ride "return" and "reject". A "return"
156 * in a child of a parallel just stops the child.
157 * It doesn't stop the parent.
158 */
159 if (cr->result.priority == MOD_ACTION_RETURN) {
161
162 } else if (cr->result.priority == MOD_ACTION_REJECT) {
164
165 } else {
168 }
169
170 /*
171 * Do priority over-ride.
172 */
173 if (cr->result.priority > state->result.priority) {
174 RDEBUG4("** [%i] %s - overwriting existing result (%s %s) from higher priority to (%s %s)",
175 stack_depth_current(request), __FUNCTION__,
180 state->result = cr->result;
181 }
182 }
183
184 /*
185 * Reap the children....
186 */
187 for (i = 0; i < state->num_children; i++) {
188 if (!state->children[i].request) continue;
189
191
193
194 state->children[i].state = CHILD_FREED;
195 }
196
197 *p_result = state->result;
199}
200
202{
203 unlang_t const *instruction;
205 unlang_parallel_t *gext;
207 int i;
208 size_t num_children;
209
211
212 num_children = unlang_list_num_elements(&g->children);
213 if (num_children == 0) RETURN_UNLANG_NOOP;
214
215 gext = unlang_group_to_parallel(g);
216
217 /*
218 * Allocate an array for the children.
219 */
220 MEM(frame->state = state = _talloc_zero_pooled_object(request,
222 (sizeof(state->children[0]) * num_children),
223 "unlang_parallel_state_t",
224 num_children,
225 (talloc_array_length(request->name) * 2)));
226 if (!state) {
227 return UNLANG_ACTION_FAIL;
228 }
229
230 (void) talloc_set_type(state, unlang_parallel_state_t);
232 state->detach = gext->detach;
233 state->clone = gext->clone;
234 state->num_children = unlang_list_num_elements(&g->children);
235
236 /*
237 * Initialize all of the children.
238 */
239 for (i = 0, instruction = unlang_list_head(&g->children);
240 instruction != NULL;
241 i++, instruction = unlang_list_next(&g->children, instruction)) {
242 request_t *child;
243 unlang_result_t *child_result;
244
245 child = unlang_io_subrequest_alloc(request,
246 request->proto_dict, state->detach);
247 child->packet->code = request->packet->code;
248
249 RDEBUG3("parallel - child %s (%d/%d) INIT",
250 child->name,
251 i + 1, state->num_children);
252
253 if (state->clone) {
254 /*
255 * Note that we do NOT copy the
256 * Session-State list! That
257 * contains state information for
258 * the parent.
259 */
260 if ((fr_pair_list_copy(child->request_ctx,
261 &child->request_pairs,
262 &request->request_pairs) < 0) ||
263 (fr_pair_list_copy(child->reply_ctx,
264 &child->reply_pairs,
265 &request->reply_pairs) < 0) ||
266 (fr_pair_list_copy(child->control_ctx,
267 &child->control_pairs,
268 &request->control_pairs) < 0)) {
269 REDEBUG("failed copying lists to child");
270 error:
271
272 /*
273 * Remove all previously
274 * spawned children.
275 */
276 for (--i; i >= 0; i--) {
278 state->children[i].state = CHILD_FREED;
279 }
280
281 return UNLANG_ACTION_FAIL;
282 }
283 }
284
285 /*
286 * Initialise our frame state, and push the first
287 * instruction onto the child's stack.
288 *
289 * This instruction will mark the parent as runnable
290 * when it is executed.
291 *
292 * We only do this if the requests aren't detached.
293 * If they are detached, this repeat function would
294 * be immediately disabled, so no point...
295 */
296 if (!state->detach) {
297 if (unlang_child_request_init(state, &state->children[i], child, NULL, &state->num_runnable,
298 frame_current(request)->instruction, false) < 0) goto error;
299 fr_assert(state->children[i].state == CHILD_INIT);
300 child_result = &state->children[i].result;
302
303 } else {
304 state->children[i].num = i;
305 state->children[i].request = child;
306 child_result = NULL;
307 }
308
309 /*
310 * Push the first instruction for the child to run,
311 * which in case of parallel, is the child's
312 * subsection within the parallel block.
313 */
314 if (unlang_interpret_push(child_result, child,
315 instruction,
317 UNLANG_NEXT_STOP) < 0) goto error;
318 }
319
320 /*
321 * Now we're sure all the children are initialised
322 * start them running.
323 */
324 if (state->detach) {
325 for (i = 0; i < (int)state->num_children; i++) {
326 if (RDEBUG_ENABLED3) {
327 request_t *parent = request;
328
329 request = state->children[i].request;
330 RDEBUG3("parallel - child %s (%d/%d) DETACHED",
331 request->name,
332 i + 1, state->num_children);
333 request = parent;
334 }
335
336 /*
337 * Adds to the runnable queue
338 */
340
341 /*
342 * Converts to a detached request
343 */
345 }
346
347 /*
348 * We are now done, all the children are detached
349 * so we don't need to wait around for them to complete.
350 */
352 }
353
354 for (i = 0; i < (int)state->num_children; i++) {
355 /*
356 * Ensure we restore the session state information
357 * into the child.
358 */
359 if (state->children[i].config.session_unique_ptr) {
361 state->children[i].config.session_unique_ptr,
362 state->children[i].num);
363 }
364
365 /*
366 * Ensures the child is setup correctly and adds
367 * it into the runnable queue of whatever owns
368 * the interpreter.
369 */
371 state->children[i].state = CHILD_RUNNABLE;
372 }
373
374 /*
375 * Don't call this function again when the parent resumes,
376 * instead call a function to process the results
377 * of the children.
378 */
380
381 /*
382 * Yield to the children
383 *
384 * They scamper off to play on their own when they're all done,
385 * the last one tells the parent, so it can resume,
386 * and gather up the results, and mercilessly reap the children.
387 */
388 return UNLANG_ACTION_YIELD;
389}
390
392{
394 unlang_t *c;
395 char const *name2;
396
398 unlang_parallel_t *gext;
399
400 bool clone = true;
401 bool detach = false;
402
403 if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
404
405 /*
406 * Parallel sections can create empty child requests, if
407 * the admin demands it. Otherwise, the principle of
408 * least surprise is to copy the whole request, reply,
409 * and config items.
410 */
411 name2 = cf_section_name2(cs);
412 if (name2) {
413 if (strcmp(name2, "empty") == 0) {
414 clone = false;
415
416 } else if (strcmp(name2, "detach") == 0) {
417 detach = true;
418
419 } else {
420 cf_log_err(cs, "Invalid argument '%s'", name2);
421 cf_log_err(ci, DOC_KEYWORD_REF(parallel));
422 return NULL;
423 }
424
425 }
426
427 /*
428 * We can do "if" in parallel with other "if", but we
429 * cannot do "else" in parallel with "if".
430 */
432 return NULL;
433 }
434
436 if (!c) return NULL;
437
439 gext = unlang_group_to_parallel(g);
440 gext->clone = clone;
441 gext->detach = detach;
442
443 return c;
444}
445
447{
449 .name = "parallel",
450 .type = UNLANG_TYPE_PARALLEL,
452
453 .compile = unlang_compile_parallel,
454 .interpret = unlang_parallel,
455 .signal = unlang_parallel_signal,
456
457 .unlang_size = sizeof(unlang_parallel_t),
458 .unlang_name = "unlang_parallel_t"
459 });
460}
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
Common header for all CONF_* types.
Definition cf_priv.h:49
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1184
char const * cf_section_name1(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1170
CONF_SECTION * cf_item_to_section(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_SECTION.
Definition cf_util.c:683
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:286
#define cf_item_next(_parent, _curr)
Definition cf_util.h:92
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.
unlang_t * unlang_compile_section(unlang_t *parent, unlang_compile_ctx_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type)
Definition compile.c:1507
bool unlang_compile_limit_subsection(CONF_SECTION *cs, char const *name)
Definition compile.c:1585
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:75
#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:1575
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1399
int unlang_interpret_push(unlang_result_t *p_result, 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:280
Declarations for the unlang interpreter.
unlang_mod_action_t priority
The priority or action for that rcode.
Definition interpret.h:136
#define UNLANG_RESULT_NOT_SET
Definition interpret.h:139
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:152
#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
#define UNLANG_RESULT_RCODE(_x)
Definition interpret.h:140
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
static TALLOC_CTX * unlang_ctx
Definition base.c:71
void unlang_register(unlang_op_t *op)
Register an operation with the interpreter.
Definition base.c:56
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
const char * mod_action_name[MOD_PRIORITY_MAX+1]
Definition mod_action.c:113
Unlang module actions.
@ MOD_ACTION_NOT_SET
default "not set by anything"
Definition mod_action.h:37
@ MOD_ACTION_RETURN
stop processing the section, and return the rcode with unset priority
Definition mod_action.h:40
@ MOD_ACTION_REJECT
change the rcode to REJECT, with unset priority
Definition mod_action.h:39
@ MOD_ACTION_RETRY
retry the instruction, MUST also set a retry config
Definition mod_action.h:38
#define MOD_ACTION_VALID(_x)
Definition mod_action.h:60
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:2321
void unlang_parallel_init(void)
Definition parallel.c:446
static unlang_action_t unlang_parallel(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Definition parallel.c:201
static unlang_t * unlang_compile_parallel(unlang_t *parent, unlang_compile_ctx_t *unlang_ctx, CONF_ITEM const *ci)
Definition parallel.c:391
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.
unlang_result_t result
our result
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:43
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:50
#define RETURN_UNLANG_NOOP
Definition rcode.h:65
#define REQUEST_VERIFY(_x)
Definition request.h:309
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.
void * state
Stack frame specialisations.
#define UNLANG_NEXT_STOP
Definition unlang_priv.h:98
#define UNLANG_IGNORE
static unlang_group_t * unlang_generic_to_group(unlang_t const *p)
static unlang_stack_frame_t * frame_current(request_t *request)
unlang_list_t children
static int stack_depth_current(request_t *request)
@ UNLANG_TYPE_PARALLEL
execute statements in parallel
Definition unlang_priv.h:55
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.
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:841
#define DOC_KEYWORD_REF(_x)
Definition version.h:89