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: 4b50b54271085e473d5dfed12693e95f78eab431 $
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: 4b50b54271085e473d5dfed12693e95f78eab431 $")
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
211
212 gext = unlang_group_to_parallel(g);
213
214 /*
215 * Allocate an array for the children.
216 */
217 MEM(frame->state = state = _talloc_zero_pooled_object(request,
219 (sizeof(state->children[0]) * g->num_children),
220 "unlang_parallel_state_t",
221 g->num_children,
222 (talloc_array_length(request->name) * 2)));
223 if (!state) {
224 return UNLANG_ACTION_FAIL;
225 }
226
227 (void) talloc_set_type(state, unlang_parallel_state_t);
229 state->detach = gext->detach;
230 state->clone = gext->clone;
231 state->num_children = g->num_children;
232
233 /*
234 * Initialize all of the children.
235 */
236 for (i = 0, instruction = g->children; instruction != NULL; i++, instruction = instruction->next) {
237 request_t *child;
238 unlang_result_t *child_result;
239
240 child = unlang_io_subrequest_alloc(request,
241 request->proto_dict, state->detach);
242 child->packet->code = request->packet->code;
243
244 RDEBUG3("parallel - child %s (%d/%d) INIT",
245 child->name,
246 i + 1, state->num_children);
247
248 if (state->clone) {
249 /*
250 * Note that we do NOT copy the
251 * Session-State list! That
252 * contains state information for
253 * the parent.
254 */
255 if ((fr_pair_list_copy(child->request_ctx,
256 &child->request_pairs,
257 &request->request_pairs) < 0) ||
258 (fr_pair_list_copy(child->reply_ctx,
259 &child->reply_pairs,
260 &request->reply_pairs) < 0) ||
261 (fr_pair_list_copy(child->control_ctx,
262 &child->control_pairs,
263 &request->control_pairs) < 0)) {
264 REDEBUG("failed copying lists to child");
265 error:
266
267 /*
268 * Remove all previously
269 * spawned children.
270 */
271 for (--i; i >= 0; i--) {
273 state->children[i].state = CHILD_FREED;
274 }
275
276 return UNLANG_ACTION_FAIL;
277 }
278 }
279
280 /*
281 * Initialise our frame state, and push the first
282 * instruction onto the child's stack.
283 *
284 * This instruction will mark the parent as runnable
285 * when it is executed.
286 *
287 * We only do this if the requests aren't detached.
288 * If they are detached, this repeat function would
289 * be immediately disabled, so no point...
290 */
291 if (!state->detach) {
292 if (unlang_child_request_init(state, &state->children[i], child, NULL, &state->num_runnable,
293 frame_current(request)->instruction, false) < 0) goto error;
294 fr_assert(state->children[i].state == CHILD_INIT);
295 child_result = &state->children[i].result;
297
298 } else {
299 state->children[i].num = i;
300 state->children[i].request = child;
301 child_result = NULL;
302 }
303
304 /*
305 * Push the first instruction for the child to run,
306 * which in case of parallel, is the child's
307 * subsection within the parallel block.
308 */
309 if (unlang_interpret_push(child_result, child,
310 instruction,
312 UNLANG_NEXT_STOP) < 0) goto error;
313 }
314
315 /*
316 * Now we're sure all the children are initialised
317 * start them running.
318 */
319 if (state->detach) {
320 for (i = 0; i < (int)state->num_children; i++) {
321 if (RDEBUG_ENABLED3) {
322 request_t *parent = request;
323
324 request = state->children[i].request;
325 RDEBUG3("parallel - child %s (%d/%d) DETACHED",
326 request->name,
327 i + 1, state->num_children);
328 request = parent;
329 }
330
331 /*
332 * Adds to the runnable queue
333 */
335
336 /*
337 * Converts to a detached request
338 */
340 }
341
342 /*
343 * We are now done, all the children are detached
344 * so we don't need to wait around for them to complete.
345 */
347 }
348
349 for (i = 0; i < (int)state->num_children; i++) {
350 /*
351 * Ensure we restore the session state information
352 * into the child.
353 */
354 if (state->children[i].config.session_unique_ptr) {
356 state->children[i].config.session_unique_ptr,
357 state->children[i].num);
358 }
359
360 /*
361 * Ensures the child is setup correctly and adds
362 * it into the runnable queue of whatever owns
363 * the interpreter.
364 */
366 state->children[i].state = CHILD_RUNNABLE;
367 }
368
369 /*
370 * Don't call this function again when the parent resumes,
371 * instead call a function to process the results
372 * of the children.
373 */
375
376 /*
377 * Yield to the children
378 *
379 * They scamper off to play on their own when they're all done,
380 * the last one tells the parent, so it can resume,
381 * and gather up the results, and mercilessly reap the children.
382 */
383 return UNLANG_ACTION_YIELD;
384}
385
387{
389 unlang_t *c;
390 char const *name2;
391
393 unlang_parallel_t *gext;
394
395 bool clone = true;
396 bool detach = false;
397
398 if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
399
400 /*
401 * Parallel sections can create empty children, if the
402 * admin demands it. Otherwise, the principle of least
403 * surprise is to copy the whole request, reply, and
404 * config items.
405 */
406 name2 = cf_section_name2(cs);
407 if (name2) {
408 if (strcmp(name2, "empty") == 0) {
409 clone = false;
410
411 } else if (strcmp(name2, "detach") == 0) {
412 detach = true;
413
414 } else {
415 cf_log_err(cs, "Invalid argument '%s'", name2);
416 cf_log_err(ci, DOC_KEYWORD_REF(parallel));
417 return NULL;
418 }
419
420 }
421
422 /*
423 * We can do "if" in parallel with other "if", but we
424 * cannot do "else" in parallel with "if".
425 */
427 return NULL;
428 }
429
431 if (!c) return NULL;
432
434 gext = unlang_group_to_parallel(g);
435 gext->clone = clone;
436 gext->detach = detach;
437
438 return c;
439}
440
442{
444 .name = "parallel",
445 .type = UNLANG_TYPE_PARALLEL,
447
448 .compile = unlang_compile_parallel,
449 .interpret = unlang_parallel,
450 .signal = unlang_parallel_signal,
451
452 .unlang_size = sizeof(unlang_parallel_t),
453 .unlang_name = "unlang_parallel_t"
454 });
455}
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:289
#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:1517
bool unlang_compile_limit_subsection(CONF_SECTION *cs, char const *name)
Definition compile.c:1597
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:76
#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:1563
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1386
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:2320
void unlang_parallel_init(void)
Definition parallel.c:441
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:386
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: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
#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)
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
#define DOC_KEYWORD_REF(_x)
Definition version.h:89