mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-12-25 20:51:42 +02:00
f0469e5857
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@20685 3c298f89-4303-0410-b956-a3cf2f4a3e73
201 lines
5.8 KiB
Diff
201 lines
5.8 KiB
Diff
--- a/uevent.c
|
|
+++ b/uevent.c
|
|
@@ -132,6 +132,8 @@ struct uevent_t *uevent_dup(const struct
|
|
|
|
dest = xmalloc(sizeof(struct uevent_t));
|
|
dest->action = src->action;
|
|
+ dest->seqnum = src->seqnum;
|
|
+ dest->action_str = strdup(src->action_str);
|
|
dest->env_vars_c = src->env_vars_c;
|
|
dest->env_vars = xmalloc(sizeof(struct env_var_t) * dest->env_vars_c);
|
|
dest->plain_s = src->plain_s;
|
|
--- a/workers/worker_fork.c
|
|
+++ b/workers/worker_fork.c
|
|
@@ -1,6 +1,69 @@
|
|
#include "worker_fork.h"
|
|
|
|
static struct worker_fork_ctx_t *global_ctx;
|
|
+static struct worker_fork_uevent_t *uevent_list;
|
|
+
|
|
+static void worker_fork_uevent_free(struct worker_fork_uevent_t *node) {
|
|
+ uevent_free(node->uevent);
|
|
+ free(node);
|
|
+}
|
|
+
|
|
+static void worker_fork_uevent_add(void *in_ctx, struct uevent_t *uevent) {
|
|
+ char **env;
|
|
+ int i;
|
|
+ struct worker_fork_ctx_t *ctx = in_ctx;
|
|
+ struct worker_fork_uevent_t *node, *walker;
|
|
+
|
|
+ node = malloc(sizeof (struct worker_fork_uevent_t));
|
|
+ node->uevent = uevent_dup(uevent);
|
|
+ node->next = NULL;
|
|
+
|
|
+ if (!uevent_list) uevent_list = node;
|
|
+ else {
|
|
+ /*
|
|
+ * Put events that need to fork first and in reverse order
|
|
+ */
|
|
+ env = xmalloc(sizeof(char *) * node->uevent->env_vars_c);
|
|
+ for (i = 0; i < node->uevent->env_vars_c; i++) {
|
|
+ env[i] = alloc_env(node->uevent->env_vars[i].key, node->uevent->env_vars[i].value);
|
|
+ putenv(env[i]);
|
|
+ }
|
|
+ if (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_SLOW) {
|
|
+ node->next = uevent_list;
|
|
+ uevent_list = node;
|
|
+ }
|
|
+ else {
|
|
+ for (walker = uevent_list; walker->next; walker = walker->next);
|
|
+ walker->next = node;
|
|
+ }
|
|
+ for (i = 0; i < node->uevent->env_vars_c; i++) {
|
|
+ unsetenv(node->uevent->env_vars[i].key);
|
|
+ free(env[i]);
|
|
+ }
|
|
+ free(env);
|
|
+ }
|
|
+}
|
|
+
|
|
+static void worker_fork_uevent_del(struct worker_fork_uevent_t *node) {
|
|
+ struct worker_fork_uevent_t *walker;
|
|
+
|
|
+ if (node == uevent_list) {
|
|
+ uevent_list = node->next;
|
|
+ }
|
|
+ else {
|
|
+ for (walker = uevent_list; walker->next; walker = walker->next)
|
|
+ if (walker->next == node) walker->next = node->next;
|
|
+ }
|
|
+ worker_fork_uevent_free(node);
|
|
+}
|
|
+
|
|
+static void worker_fork_uevent_empty(void) {
|
|
+ struct worker_fork_uevent_t *walker;
|
|
+
|
|
+ if (!uevent_list) return;
|
|
+ for (walker = uevent_list; walker->next; walker = walker->next) worker_fork_uevent_free(walker);
|
|
+ uevent_list = NULL;
|
|
+}
|
|
|
|
/**
|
|
* Destroys data structures related to the given child ID (not PID).
|
|
@@ -315,6 +378,8 @@ static void *worker_fork_init(struct set
|
|
struct worker_fork_ctx_t *ctx;
|
|
PRINTFUNC();
|
|
|
|
+ uevent_list = NULL;
|
|
+
|
|
ctx = malloc(sizeof(struct worker_fork_ctx_t));
|
|
ctx->children = NULL;
|
|
ctx->children_count = 0;
|
|
@@ -376,6 +441,7 @@ static void worker_fork_deinit(void *in_
|
|
free(ctx->children);
|
|
free(ctx);
|
|
global_ctx = NULL;
|
|
+ worker_fork_uevent_empty();
|
|
}
|
|
|
|
|
|
@@ -384,15 +450,26 @@ static int worker_fork_process(void *in_
|
|
int i;
|
|
struct worker_fork_child_t *child;
|
|
struct worker_fork_ctx_t *ctx = in_ctx;
|
|
+ struct worker_fork_uevent_t *node, *walker;
|
|
+ event_seqnum_t seqnum;
|
|
+
|
|
+ worker_fork_uevent_add(ctx, uevent);
|
|
+ walker = uevent_list;
|
|
|
|
/*
|
|
- * A big loop, because if we fail to process the event,
|
|
+ * A big loop, because if we fail to process the events,
|
|
* we don't want to give up.
|
|
*
|
|
* TODO: Decide if we want to limit the number of attempts
|
|
* or set a time limit before reporting terminal failure.
|
|
*/
|
|
do {
|
|
+ /*
|
|
+ * If more events are waiting, return to receive them
|
|
+ */
|
|
+ if (!seqnum_get(&seqnum) && seqnum > uevent->seqnum) break;
|
|
+
|
|
+ node = walker;
|
|
worker_fork_update_children(ctx);
|
|
|
|
child = NULL;
|
|
@@ -407,9 +484,9 @@ static int worker_fork_process(void *in_
|
|
* No child process is currently available.
|
|
*/
|
|
if (child == NULL) {
|
|
- env = xmalloc(sizeof(char *) * uevent->env_vars_c);
|
|
- for (i = 0; i < uevent->env_vars_c; i++) {
|
|
- env[i] = alloc_env(uevent->env_vars[i].key, uevent->env_vars[i].value);
|
|
+ env = xmalloc(sizeof(char *) * node->uevent->env_vars_c);
|
|
+ for (i = 0; i < node->uevent->env_vars_c; i++) {
|
|
+ env[i] = alloc_env(node->uevent->env_vars[i].key, node->uevent->env_vars[i].value);
|
|
putenv(env[i]);
|
|
}
|
|
|
|
@@ -418,8 +495,11 @@ static int worker_fork_process(void *in_
|
|
* can execute them in the main process?
|
|
*/
|
|
if (ctx->always_fork == 0 && ctx->settings->dumb == 0 &&
|
|
- (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_MASK_SLOW) == 0) {
|
|
- action_perform(ctx->settings, uevent);
|
|
+ (ruleset_flags(&ctx->settings->rules, node->uevent) & FLAG_MASK_SLOW) == 0) {
|
|
+ action_perform(ctx->settings, node->uevent);
|
|
+ walker = walker->next;
|
|
+ worker_fork_uevent_del(node);
|
|
+ if (walker) continue;
|
|
break;
|
|
}
|
|
|
|
@@ -427,11 +507,11 @@ static int worker_fork_process(void *in_
|
|
* We have to fork off a new child.
|
|
*/
|
|
if (ctx->children_count < ctx->max_children ||
|
|
- (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_SLOW))
|
|
+ (ruleset_flags(&ctx->settings->rules, node->uevent) & FLAG_SLOW))
|
|
child = worker_fork_spawn(ctx);
|
|
|
|
- for (i = 0; i < uevent->env_vars_c; i++) {
|
|
- unsetenv(uevent->env_vars[i].key);
|
|
+ for (i = 0; i < node->uevent->env_vars_c; i++) {
|
|
+ unsetenv(node->uevent->env_vars[i].key);
|
|
free(env[i]);
|
|
}
|
|
free(env);
|
|
@@ -442,9 +522,14 @@ static int worker_fork_process(void *in_
|
|
*/
|
|
if (child != NULL) {
|
|
child->busy = 1;
|
|
- if (!worker_fork_relay_event(child->event_fd, uevent));
|
|
- break;
|
|
- child->busy = 0;
|
|
+ if (worker_fork_relay_event(child->event_fd, node->uevent)) {
|
|
+ child->busy = 0;
|
|
+ continue;
|
|
+ }
|
|
+ walker = walker->next;
|
|
+ worker_fork_uevent_del(node);
|
|
+ if (walker) continue;
|
|
+ break;
|
|
}
|
|
|
|
/*
|
|
--- a/workers/worker_fork.h
|
|
+++ b/workers/worker_fork.h
|
|
@@ -35,4 +35,9 @@ struct worker_fork_ctx_t {
|
|
struct settings_t *settings;
|
|
};
|
|
|
|
+struct worker_fork_uevent_t {
|
|
+ struct uevent_t *uevent;
|
|
+ struct worker_fork_uevent_t *next;
|
|
+};
|
|
+
|
|
#endif
|