diff options
| -rw-r--r-- | include/ouroboros/utils.h | 3 | ||||
| -rw-r--r-- | src/irmd/CMakeLists.txt | 9 | ||||
| -rw-r--r-- | src/irmd/configfile.c | 2 | ||||
| -rw-r--r-- | src/irmd/irmd.h | 10 | ||||
| -rw-r--r-- | src/irmd/main.c | 1003 | ||||
| -rw-r--r-- | src/irmd/proc_table.c | 297 | ||||
| -rw-r--r-- | src/irmd/prog_table.c | 163 | ||||
| -rw-r--r-- | src/irmd/reg/flow.c (renamed from src/irmd/irm_flow.c) | 74 | ||||
| -rw-r--r-- | src/irmd/reg/flow.h (renamed from src/irmd/irm_flow.h) | 24 | ||||
| -rw-r--r-- | src/irmd/reg/ipcp.c | 152 | ||||
| -rw-r--r-- | src/irmd/reg/ipcp.h | 58 | ||||
| -rw-r--r-- | src/irmd/reg/name.c | 451 | ||||
| -rw-r--r-- | src/irmd/reg/name.h | 103 | ||||
| -rw-r--r-- | src/irmd/reg/proc.c | 265 | ||||
| -rw-r--r-- | src/irmd/reg/proc.h (renamed from src/irmd/proc_table.h) | 45 | ||||
| -rw-r--r-- | src/irmd/reg/prog.c | 174 | ||||
| -rw-r--r-- | src/irmd/reg/prog.h (renamed from src/irmd/prog_table.h) | 36 | ||||
| -rw-r--r-- | src/irmd/registry.c | 577 | ||||
| -rw-r--r-- | src/irmd/registry.h | 122 | ||||
| -rw-r--r-- | src/irmd/utils.c | 17 | ||||
| -rw-r--r-- | src/irmd/utils.h | 2 | ||||
| -rw-r--r-- | src/lib/utils.c | 6 |
22 files changed, 1826 insertions, 1767 deletions
diff --git a/include/ouroboros/utils.h b/include/ouroboros/utils.h index f5f8610d..be345c19 100644 --- a/include/ouroboros/utils.h +++ b/include/ouroboros/utils.h @@ -38,7 +38,6 @@ typedef struct { size_t len; } buffer_t; - /* * Returns the number of characters a uint would * need when represented as a string @@ -46,7 +45,7 @@ typedef struct { int n_digits(unsigned i); /* gets the application name */ -char * path_strip(char * src); +char * path_strip(const char * src); /* destroy a ** */ #define freepp(type, ptr, len) \ diff --git a/src/irmd/CMakeLists.txt b/src/irmd/CMakeLists.txt index 8472e1e7..fba63a62 100644 --- a/src/irmd/CMakeLists.txt +++ b/src/irmd/CMakeLists.txt @@ -62,14 +62,15 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in" set(SOURCE_FILES # Add source files here - proc_table.c - prog_table.c ipcp.c configfile.c - irm_flow.c main.c - registry.c utils.c + reg/flow.c + reg/ipcp.c + reg/proc.c + reg/prog.c + reg/name.c ) add_executable (irmd ${SOURCE_FILES}) diff --git a/src/irmd/configfile.c b/src/irmd/configfile.c index 787edb49..38a24433 100644 --- a/src/irmd/configfile.c +++ b/src/irmd/configfile.c @@ -603,7 +603,7 @@ static int toml_prog(char * prog, const char * name) { uint16_t flags = 0; - int argc = 0; + int argc; char ** argv; int ret; diff --git a/src/irmd/irmd.h b/src/irmd/irmd.h index 92c26818..a225a2dd 100644 --- a/src/irmd/irmd.h +++ b/src/irmd/irmd.h @@ -52,10 +52,10 @@ int name_reg(const char * name, int bind_process(pid_t pid, const char * name); -int bind_program(char * prog, - const char * name, - uint16_t flags, - int argc, - char ** argv); +int bind_program(const char * prog, + const char * name, + uint16_t flags, + int argc, + char ** argv); #endif /* OUROBOROS_IRMD_H*/
\ No newline at end of file diff --git a/src/irmd/main.c b/src/irmd/main.c index 75e6c2c7..f35b0513 100644 --- a/src/irmd/main.c +++ b/src/irmd/main.c @@ -47,13 +47,15 @@ #include <ouroboros/version.h> #include <ouroboros/pthread.h> -#include "utils.h" -#include "registry.h" #include "irmd.h" -#include "irm_flow.h" -#include "proc_table.h" #include "ipcp.h" +#include "reg/flow.h" +#include "reg/ipcp.h" +#include "reg/name.h" +#include "reg/proc.h" +#include "reg/prog.h" #include "configfile.h" +#include "utils.h" #include <sys/socket.h> #include <sys/un.h> @@ -71,29 +73,12 @@ #define IRMD_CLEANUP_TIMER ((IRMD_FLOW_TIMEOUT / 20) * MILLION) /* ns */ #define SHM_SAN_HOLDOFF 1000 /* ms */ -#define IPCP_HASH_LEN(e) hash_len(e->dir_hash_algo) +#define IPCP_HASH_LEN(p) hash_len((p)->dir_hash_algo) #define BIND_TIMEOUT 10 /* ms */ #define DEALLOC_TIME 300 /* s */ -enum init_state { - IPCP_NULL = 0, - IPCP_BOOT, - IPCP_LIVE -}; - -struct ipcp_entry { - struct list_head next; - - char * name; - pid_t pid; - enum ipcp_type type; - enum hash_algo dir_hash_algo; - char * layer; - - enum init_state state; - pthread_cond_t cond; - pthread_mutex_t lock; -}; +#define registry_has_name(name) \ + (registry_get_name(name) != NULL) enum irm_state { IRMD_NULL = 0, @@ -111,19 +96,19 @@ struct cmd { struct { bool log_stdout; /* log to stdout */ - struct list_head registry; /* registered names known */ + struct list_head names; /* registered names known */ size_t n_names; /* number of names */ struct list_head ipcps; /* list of ipcps in system */ size_t n_ipcps; /* number of ipcps */ - struct list_head proc_table; /* processes */ - struct list_head prog_table; /* programs known */ + struct list_head procs; /* processes */ + struct list_head progs; /* programs known */ struct list_head spawned_pids; /* child processes */ pthread_rwlock_t reg_lock; /* lock for registration info */ struct bmp * flow_ids; /* flow_ids for flows */ - struct list_head irm_flows; /* flow information */ + struct list_head flows; /* flow information */ pthread_rwlock_t flows_lock; /* lock for flows */ #ifdef HAVE_TOML char * cfg_file; /* configuration file path */ @@ -168,7 +153,7 @@ static void irmd_set_state(enum irm_state state) pthread_rwlock_unlock(&irmd.state_lock); } -static void clear_irm_flow(struct irm_flow * f) { +static void clear_reg_flow(struct reg_flow * f) { ssize_t idx; assert(f); @@ -185,26 +170,26 @@ static void clear_irm_flow(struct irm_flow * f) { shm_rdrbuff_remove(irmd.rdrb, idx); } -static struct irm_flow * get_irm_flow(int flow_id) +static struct reg_flow * registry_get_flow(int flow_id) { - struct list_head * pos = NULL; + struct list_head * p; - list_for_each(pos, &irmd.irm_flows) { - struct irm_flow * e = list_entry(pos, struct irm_flow, next); - if (e->flow_id == flow_id) - return e; + list_for_each(p, &irmd.flows) { + struct reg_flow * f = list_entry(p, struct reg_flow, next); + if (f->flow_id == flow_id) + return f; } return NULL; } -static struct irm_flow * get_irm_flow_n(pid_t n_pid) +static struct reg_flow * registry_get_pending_flow_for_pid(pid_t n_pid) { - struct list_head * pos = NULL; + struct list_head * p; - list_for_each(pos, &irmd.irm_flows) { - struct irm_flow * e = list_entry(pos, struct irm_flow, next); - enum flow_state state = irm_flow_get_state(e); + list_for_each(p, &irmd.flows) { + struct reg_flow * e = list_entry(p, struct reg_flow, next); + enum flow_state state = reg_flow_get_state(e); if (e->n_pid == n_pid && state == FLOW_ALLOC_REQ_PENDING) return e; } @@ -212,115 +197,29 @@ static struct irm_flow * get_irm_flow_n(pid_t n_pid) return NULL; } -static struct ipcp_entry * ipcp_entry_create(const char * name, - enum ipcp_type type) -{ - struct ipcp_entry * e; - pthread_condattr_t cattr; - - e = malloc(sizeof(*e)); - if (e == NULL) - goto fail_malloc; - - e->layer = NULL; - e->type = type; - e->state = IPCP_BOOT; - e->name = strdup(name); - if (e->name == NULL) - goto fail_name; - - if (pthread_condattr_init(&cattr)) - goto fail_cattr; -#ifndef __APPLE__ - pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); -#endif - if (pthread_cond_init(&e->cond, &cattr)) - goto fail_cond; - - if (pthread_mutex_init(&e->lock, NULL)) - goto fail_mutex; - - - list_head_init(&e->next); - - pthread_condattr_destroy(&cattr); - - return e; - - fail_mutex: - pthread_cond_destroy(&e->cond); - fail_cond: - pthread_condattr_destroy(&cattr); - fail_cattr: - free(e->name); - fail_name: - free(e); - fail_malloc: - return NULL; -} - -static void ipcp_entry_destroy(struct ipcp_entry * e) -{ - assert(e); - - pthread_mutex_lock(&e->lock); - - while (e->state == IPCP_BOOT) - pthread_cond_wait(&e->cond, &e->lock); - - pthread_mutex_unlock(&e->lock); - - free(e->name); - free(e->layer); - free(e); -} - -static void ipcp_entry_set_state(struct ipcp_entry * e, - enum init_state state) -{ - pthread_mutex_lock(&e->lock); - e->state = state; - pthread_cond_broadcast(&e->cond); - pthread_mutex_unlock(&e->lock); -} - -static int ipcp_entry_wait_boot(struct ipcp_entry * e) +static int registry_add_ipcp(struct reg_ipcp * ipcp) { - int ret = 0; - struct timespec dl; - struct timespec to = {SOCKET_TIMEOUT / 1000, - (SOCKET_TIMEOUT % 1000) * MILLION}; - - clock_gettime(PTHREAD_COND_CLOCK, &dl); - ts_add(&dl, &to, &dl); - - pthread_mutex_lock(&e->lock); - - while (e->state == IPCP_BOOT && ret != ETIMEDOUT) - ret = pthread_cond_timedwait(&e->cond, &e->lock, &dl); + struct list_head * p; - if (ret == ETIMEDOUT) { - kill(e->pid, SIGTERM); - e->state = IPCP_NULL; - pthread_cond_signal(&e->cond); - } + assert(ipcp); - if (e->state != IPCP_LIVE) { - pthread_mutex_unlock(&e->lock); - return -1; + list_for_each(p, &irmd.ipcps) { + if (list_entry(p, struct reg_ipcp, next)->type > ipcp->type) + break; } - pthread_mutex_unlock(&e->lock); + list_add_tail(&ipcp->next, p); + ++irmd.n_ipcps; return 0; } -static struct ipcp_entry * get_ipcp_entry_by_pid(pid_t pid) +static struct reg_ipcp * registry_get_ipcp_by_pid(pid_t pid) { struct list_head * p; list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); if (e->pid == pid) return e; } @@ -328,12 +227,25 @@ static struct ipcp_entry * get_ipcp_entry_by_pid(pid_t pid) return NULL; } -static struct ipcp_entry * get_ipcp_entry_by_name(const char * name) +static void registry_del_ipcp(pid_t pid) +{ + struct reg_ipcp * ipcp; + + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL) + return; + + list_del(&ipcp->next); + reg_ipcp_destroy(ipcp); + --irmd.n_ipcps; +} + +static struct reg_ipcp * registry_get_ipcp_by_name(const char * name) { struct list_head * p; list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); if (strcmp(name, e->name) == 0) return e; } @@ -341,12 +253,12 @@ static struct ipcp_entry * get_ipcp_entry_by_name(const char * name) return NULL; } -static struct ipcp_entry * get_ipcp_entry_by_layer(const char * layer) +static struct reg_ipcp * registry_get_ipcp_by_layer(const char * layer) { struct list_head * p; list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); if (strcmp(layer, e->layer) == 0) return e; } @@ -354,8 +266,8 @@ static struct ipcp_entry * get_ipcp_entry_by_layer(const char * layer) return NULL; } -static struct ipcp_entry * get_ipcp_by_dst_name(const char * name, - pid_t src) +static struct reg_ipcp *registry_get_ipcp_by_dst_name(const char * name, + pid_t src) { struct list_head * p; struct list_head * h; @@ -366,7 +278,7 @@ static struct ipcp_entry * get_ipcp_by_dst_name(const char * name, pthread_rwlock_rdlock(&irmd.reg_lock); list_for_each_safe(p, h, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); if (e->layer == NULL || e->pid == src || e->type == IPCP_BROADCAST) continue; @@ -402,15 +314,15 @@ static struct ipcp_entry * get_ipcp_by_dst_name(const char * name, int get_layer_for_ipcp(pid_t pid, char * buf) { - struct ipcp_entry * entry; + struct reg_ipcp * ipcp; pthread_rwlock_rdlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); - if (entry == NULL || entry->layer == NULL) + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL || ipcp->layer == NULL) goto fail; - strcpy(buf, entry->layer); + strcpy(buf, ipcp->layer); pthread_rwlock_unlock(&irmd.reg_lock); @@ -421,19 +333,183 @@ int get_layer_for_ipcp(pid_t pid, return -1; } +static struct reg_name * registry_get_name(const char * name) +{ + struct list_head * p; + + list_for_each(p, &irmd.names) { + struct reg_name * e = list_entry(p, struct reg_name, next); + if (!strcmp(name, e->name)) + return e; + } + + return NULL; +} + +static struct reg_name * registry_get_name_by_hash(enum hash_algo algo, + const uint8_t * hash, + size_t len) +{ + struct list_head * p; + uint8_t * thash; + + thash = malloc(len); + if (thash == NULL) + return NULL; + + list_for_each(p, &irmd.names) { + struct reg_name * n = list_entry(p, struct reg_name, next); + str_hash(algo, thash, n->name); + if (memcmp(thash, hash, len) == 0) { + free(thash); + return n; + } + } + + free(thash); + + return NULL; +} + +static int registry_add_name(struct reg_name * n) +{ + + assert(n); + + list_add(&n->next, &irmd.names); + + ++irmd.n_names; + + return 0; +} + +static void registry_del_name(const char * name) +{ + struct reg_name * n; + + n = registry_get_name(name); + if (n == NULL) + return; + + list_del(&n->next); + reg_name_destroy(n); + --irmd.n_names; +} + +static void registry_names_del_proc(pid_t pid) +{ + struct list_head * p; + + assert(pid > 0); + + list_for_each(p, &irmd.names) { + struct reg_name * n = list_entry(p, struct reg_name, next); + reg_name_del_pid(n, pid); + } + + return; +} + +static void registry_destroy_names(void) +{ + struct list_head * p; + struct list_head * h; + + list_for_each_safe(p, h, &irmd.names) { + struct reg_name * n = list_entry(p, struct reg_name, next); + list_del(&n->next); + reg_name_set_state(n, NAME_NULL); + reg_name_destroy(n); + } +} + +static int registry_add_prog(struct reg_prog * p) +{ + assert(p); + + list_add(&p->next, &irmd.progs); + + return 0; +} + +static void registry_del_prog(const char * prog) +{ + struct list_head * p; + struct list_head * h; + + assert(prog); + + list_for_each_safe(p, h, &irmd.progs) { + struct reg_prog * e = list_entry(p, struct reg_prog, next); + if (!strcmp(prog, e->prog)) { + list_del(&e->next); + reg_prog_destroy(e); + } + } +} + +static struct reg_prog * registry_get_prog(const char * prog) +{ + struct list_head * p; + + assert(prog); + + list_for_each(p, &irmd.progs) { + struct reg_prog * e = list_entry(p, struct reg_prog, next); + if (!strcmp(e->prog, prog)) + return e; + } + + return NULL; +} + +static int registry_add_proc(struct reg_proc * p) +{ + assert(p); + + list_add(&p->next, &irmd.procs); + + return 0; +} + +static void registry_del_proc(pid_t pid) +{ + struct list_head * p; + struct list_head * h; + + list_for_each_safe(p, h, &irmd.procs) { + struct reg_proc * e = list_entry(p, struct reg_proc, next); + if (pid == e->pid) { + list_del(&e->next); + reg_proc_destroy(e); + } + } +} + +static struct reg_proc * registry_get_proc(pid_t pid) +{ + struct list_head * p; + + list_for_each(p, &irmd.procs) { + struct reg_proc * e = list_entry(p, struct reg_proc, next); + if (pid == e->pid) + return e; + } + + return NULL; +} pid_t create_ipcp(const char * name, enum ipcp_type type) { - struct pid_el * ppid; - struct ipcp_entry * entry; - struct list_head * p; - pid_t pid; + struct pid_el * ppid; + struct reg_ipcp * ipcp; + pid_t pid; pthread_rwlock_rdlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_name(name); - if (entry != NULL) { + ipcp = registry_get_ipcp_by_name(name); + if (ipcp != NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("IPCP by that name already exists."); return -EPERM; @@ -445,10 +521,10 @@ pid_t create_ipcp(const char * name, if (ppid == NULL) goto fail_ppid; - entry = ipcp_entry_create(name, type); - if (entry == NULL) { + ipcp = reg_ipcp_create(name, type); + if (ipcp == NULL) { log_err("Failed to create IPCP entry."); - goto fail_ipcp_entry; + goto fail_reg_ipcp; } pid = ipcp_create(name, type); @@ -457,25 +533,19 @@ pid_t create_ipcp(const char * name, goto fail_ipcp; } - entry->pid = pid; + ipcp->pid = pid; pthread_rwlock_wrlock(&irmd.reg_lock); - list_for_each(p, &irmd.ipcps) { - if (list_entry(p, struct ipcp_entry, next)->type > type) - break; - } - - list_add_tail(&entry->next, p); - ++irmd.n_ipcps; + registry_add_ipcp(ipcp); - ppid->pid = entry->pid; + ppid->pid = ipcp->pid; list_add(&ppid->next, &irmd.spawned_pids); pthread_rwlock_unlock(&irmd.reg_lock); /* IRMd maintenance will clean up if booting fails. */ - if (ipcp_entry_wait_boot(entry)) { + if (reg_ipcp_wait_boot(ipcp)) { log_err("IPCP %d failed to boot.", pid); return -1; } @@ -485,8 +555,8 @@ pid_t create_ipcp(const char * name, return pid; fail_ipcp: - ipcp_entry_destroy(entry); - fail_ipcp_entry: + reg_ipcp_destroy(ipcp); + fail_reg_ipcp: free(ppid); fail_ppid: return -1; @@ -500,9 +570,9 @@ static int create_ipcp_r(pid_t pid, pthread_rwlock_rdlock(&irmd.reg_lock); list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); if (e->pid == pid) { - ipcp_entry_set_state(e, result ? IPCP_NULL : IPCP_LIVE); + reg_ipcp_set_state(e, result ? IPCP_NULL : IPCP_LIVE); break; } } @@ -528,38 +598,29 @@ static void clear_spawned_process(pid_t pid) static int destroy_ipcp(pid_t pid) { - struct list_head * p; - struct list_head * h; - pthread_rwlock_wrlock(&irmd.reg_lock); - list_for_each_safe(p, h, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); - if (e->pid == pid) { - clear_spawned_process(pid); - if (ipcp_destroy(pid)) - log_err("Could not destroy IPCP."); - list_del(&e->next); - ipcp_entry_destroy(e); - --irmd.n_ipcps; - log_info("Destroyed IPCP %d.", pid); - } - } + registry_del_ipcp(pid); + + clear_spawned_process(pid); pthread_rwlock_unlock(&irmd.reg_lock); + if (ipcp_destroy(pid)) + log_err("Could not destroy IPCP."); + return 0; } int bootstrap_ipcp(pid_t pid, struct ipcp_config * conf) { - struct ipcp_entry * entry; + struct reg_ipcp * entry; struct layer_info info; pthread_rwlock_wrlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); + entry = registry_get_ipcp_by_pid(pid); if (entry == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("No such IPCP."); @@ -598,19 +659,19 @@ int bootstrap_ipcp(pid_t pid, int enroll_ipcp(pid_t pid, const char * dst) { - struct ipcp_entry * entry = NULL; - struct layer_info info; + struct reg_ipcp * ipcp; + struct layer_info info; - pthread_rwlock_wrlock(&irmd.reg_lock); + pthread_rwlock_rdlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); - if (entry == NULL) { + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("No such IPCP."); return -1; } - if (entry->layer != NULL) { + if (ipcp->layer != NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("IPCP in wrong state"); return -1; @@ -625,21 +686,21 @@ int enroll_ipcp(pid_t pid, pthread_rwlock_wrlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); - if (entry == NULL) { + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("No such IPCP."); return -1; } - entry->layer = strdup(info.layer_name); - if (entry->layer == NULL) { + ipcp->layer = strdup(info.layer_name); + if (ipcp->layer == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Failed to strdup layer_name."); return -ENOMEM; } - entry->dir_hash_algo = info.dir_hash_algo; + ipcp->dir_hash_algo = info.dir_hash_algo; pthread_rwlock_unlock(&irmd.reg_lock); @@ -650,22 +711,22 @@ int enroll_ipcp(pid_t pid, } int connect_ipcp(pid_t pid, - const char * dst, - const char * component, - qosspec_t qs) + const char * dst, + const char * component, + qosspec_t qs) { - struct ipcp_entry * entry = NULL; + struct reg_ipcp * ipcp; pthread_rwlock_rdlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); - if (entry == NULL) { + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("No such IPCP."); return -EIPCP; } - if (entry->type != IPCP_UNICAST && entry->type != IPCP_BROADCAST) { + if (ipcp->type != IPCP_UNICAST && ipcp->type != IPCP_BROADCAST) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Cannot establish connections for this IPCP type."); return -EIPCP; @@ -690,18 +751,18 @@ static int disconnect_ipcp(pid_t pid, const char * dst, const char * component) { - struct ipcp_entry * entry = NULL; + struct reg_ipcp * ipcp; pthread_rwlock_rdlock(&irmd.reg_lock); - entry = get_ipcp_entry_by_pid(pid); - if (entry == NULL) { + ipcp = registry_get_ipcp_by_pid(pid); + if (ipcp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("No such IPCP."); return -EIPCP; } - if (entry->type != IPCP_UNICAST) { + if (ipcp->type != IPCP_UNICAST && ipcp->type != IPCP_BROADCAST) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Cannot tear down connections for this IPCP type."); return -EIPCP; @@ -720,75 +781,39 @@ static int disconnect_ipcp(pid_t pid, return 0; } -int bind_program(char * prog, - const char * name, - uint16_t flags, - int argc, - char ** argv) +int bind_program(const char * prog, + const char * name, + uint16_t flags, + int argc, + char ** argv) { - char * progs; - char ** argv_dup = NULL; - int i; - char * name_dup = NULL; - struct prog_entry * e = NULL; - struct reg_entry * re = NULL; + struct reg_prog * p; + struct reg_name * n; if (prog == NULL || name == NULL) return -EINVAL; pthread_rwlock_wrlock(&irmd.reg_lock); - e = prog_table_get(&irmd.prog_table, path_strip(prog)); - if (e == NULL) { - progs = strdup(path_strip(prog)); - if (progs == NULL) { + p = registry_get_prog(path_strip(prog)); + if (p == NULL) { + p = reg_prog_create(prog, flags, argc, argv); + if (p == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); return -ENOMEM; } - if ((flags & BIND_AUTO) && argc > 0) { - /* We need to duplicate argv and set argv[0] to prog. */ - argv_dup = malloc((argc + 2) * sizeof(*argv_dup)); - argv_dup[0] = strdup(prog); - for (i = 1; i <= argc; ++i) { - argv_dup[i] = strdup(argv[i - 1]); - if (argv_dup[i] != NULL) - continue; - - pthread_rwlock_unlock(&irmd.reg_lock); - log_err("Failed to bind program %s to %s.", - prog, name); - argvfree(argv_dup); - free(progs); - return -ENOMEM; - } - argv_dup[argc + 1] = NULL; - } - e = prog_entry_create(progs, flags, argv_dup); - if (e == NULL) { - pthread_rwlock_unlock(&irmd.reg_lock); - free(progs); - argvfree(argv_dup); - return -ENOMEM; - } - prog_table_add(&irmd.prog_table, e); + registry_add_prog(p); } - name_dup = strdup(name); - if (name_dup == NULL) { - pthread_rwlock_unlock(&irmd.reg_lock); - return -ENOMEM; - } - - if (prog_entry_add_name(e, name_dup)) { + if (reg_prog_add_name(p, name)) { log_err("Failed adding name."); pthread_rwlock_unlock(&irmd.reg_lock); - free(name_dup); return -ENOMEM; } - re = registry_get_entry(&irmd.registry, name); - if (re != NULL && reg_entry_add_prog(re, e) < 0) + n = registry_get_name(name); + if (n != NULL && reg_name_add_prog(n, p) < 0) log_err("Failed adding program %s for name %s.", prog, name); pthread_rwlock_unlock(&irmd.reg_lock); @@ -801,11 +826,10 @@ int bind_program(char * prog, int bind_process(pid_t pid, const char * name) { - char * name_dup = NULL; - struct proc_entry * e = NULL; - struct reg_entry * re = NULL; - struct timespec now; - struct timespec dl = {0, 10 * MILLION}; + struct reg_proc * pc = NULL; + struct reg_name * rn; + struct timespec now; + struct timespec dl = {0, 10 * MILLION}; if (name == NULL) return -EINVAL; @@ -817,35 +841,28 @@ int bind_process(pid_t pid, pthread_rwlock_wrlock(&irmd.reg_lock); while (!kill(pid, 0)) { - e = proc_table_get(&irmd.proc_table, pid); - if (e != NULL || ts_diff_ms(&now, &dl) > 0) + pc = registry_get_proc(pid); + if (pc != NULL || ts_diff_ms(&now, &dl) > 0) break; clock_gettime(PTHREAD_COND_CLOCK, &now); sched_yield(); } - if (e == NULL) { + if (pc == NULL) { log_err("Process %d does not %s.", pid, kill(pid, 0) ? "exist" : "respond"); pthread_rwlock_unlock(&irmd.reg_lock); return -1; } - name_dup = strdup(name); - if (name_dup == NULL) { - pthread_rwlock_unlock(&irmd.reg_lock); - return -ENOMEM; - } - - if (proc_entry_add_name(e, name_dup)) { + if (reg_proc_add_name(pc, name)) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Failed to add name %s to process %d.", name, pid); - free(name_dup); return -1; } - re = registry_get_entry(&irmd.registry, name); - if (re != NULL && reg_entry_add_pid(re, pid) < 0) + rn = registry_get_name(name); + if (rn != NULL && reg_name_add_pid(rn, pid) < 0) log_err("Failed adding process %d for name %s.", pid, name); pthread_rwlock_unlock(&irmd.reg_lock); @@ -855,30 +872,31 @@ int bind_process(pid_t pid, return 0; } -static int unbind_program(char * prog, - char * name) +static int unbind_program(const char * prog, + const char * name) { - struct reg_entry * e; - if (prog == NULL) return -EINVAL; pthread_rwlock_wrlock(&irmd.reg_lock); if (name == NULL) - prog_table_del(&irmd.prog_table, prog); + registry_del_prog(prog); else { - struct prog_entry * en = prog_table_get(&irmd.prog_table, prog); - if (en == NULL) { + struct reg_name * rn; + struct reg_prog * pg; + + pg = registry_get_prog(prog); + if (pg == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); return -EINVAL; } - prog_entry_del_name(en, name); + reg_prog_del_name(pg, name); - e = registry_get_entry(&irmd.registry, name); - if (e != NULL) - reg_entry_del_prog(e, prog); + rn = registry_get_name(name); + if (rn != NULL) + reg_name_del_prog(rn, prog); } pthread_rwlock_unlock(&irmd.reg_lock); @@ -894,20 +912,21 @@ static int unbind_program(char * prog, static int unbind_process(pid_t pid, const char * name) { - struct reg_entry * e; - pthread_rwlock_wrlock(&irmd.reg_lock); if (name == NULL) - proc_table_del(&irmd.proc_table, pid); + registry_del_proc(pid); else { - struct proc_entry * en = proc_table_get(&irmd.proc_table, pid); - if (en != NULL) - proc_entry_del_name(en, name); + struct reg_name * n; + struct reg_proc * p; - e = registry_get_entry(&irmd.registry, name); - if (e != NULL) - reg_entry_del_pid(e, pid); + p = registry_get_proc(pid); + if (p != NULL) + reg_proc_del_name(p, name); + + n = registry_get_name(name); + if (n != NULL) + reg_name_del_pid(n, pid); } pthread_rwlock_unlock(&irmd.reg_lock); @@ -942,7 +961,7 @@ static ssize_t list_ipcps(ipcp_info_msg_t *** ipcps, } list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); (*ipcps)[i] = malloc(sizeof(***ipcps)); if ((*ipcps)[i] == NULL) { --i; @@ -980,52 +999,56 @@ static ssize_t list_ipcps(ipcp_info_msg_t *** ipcps, } int name_create(const char * name, - enum pol_balance pol) + enum pol_balance lb) { - struct reg_entry * re; + struct reg_name * n; struct list_head * p; assert(name); pthread_rwlock_wrlock(&irmd.reg_lock); - if (registry_has_name(&irmd.registry, name)) { + if (registry_has_name(name)) { pthread_rwlock_unlock(&irmd.reg_lock); - log_warn("Registry entry for %s already exists.", name); + log_warn("Name %s already exists.", name); return 0; } - re = registry_add_name(&irmd.registry, name); - if (re == NULL) { + n = reg_name_create(name, lb); + if (n == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); - log_err("Failed creating registry entry for %s.", name); + log_dbg("Could not create name."); + return -ENOMEM; + } + + if (registry_add_name(n) < 0) { + pthread_rwlock_unlock(&irmd.reg_lock); + log_err("Failed to add name %s.", name); return -ENOMEM; } - ++irmd.n_names; - reg_entry_set_policy(re, pol); /* check the tables for existing bindings */ - list_for_each(p, &irmd.proc_table) { + list_for_each(p, &irmd.procs) { struct list_head * q; - struct proc_entry * e; - e = list_entry(p, struct proc_entry, next); + struct reg_proc * e; + e = list_entry(p, struct reg_proc, next); list_for_each(q, &e->names) { struct str_el * s; s = list_entry(q, struct str_el, next); if (!strcmp(s->str, name)) - reg_entry_add_pid(re, e->pid); + reg_name_add_pid(n, e->pid); } } - list_for_each(p, &irmd.prog_table) { + list_for_each(p, &irmd.progs) { struct list_head * q; - struct prog_entry * e; - e = list_entry(p, struct prog_entry, next); + struct reg_prog * e; + e = list_entry(p, struct reg_prog, next); list_for_each(q, &e->names) { struct str_el * s; s = list_entry(q, struct str_el, next); if (!strcmp(s->str, name)) - reg_entry_add_prog(re, e); + reg_name_add_prog(n, e); } } @@ -1042,14 +1065,13 @@ static int name_destroy(const char * name) pthread_rwlock_wrlock(&irmd.reg_lock); - if (!registry_has_name(&irmd.registry, name)) { + if (!registry_has_name(name)) { pthread_rwlock_unlock(&irmd.reg_lock); log_warn("Registry entry for %s does not exist.", name); return -ENAME; } - registry_del_name(&irmd.registry, name); - --irmd.n_names; + registry_del_name(name); pthread_rwlock_unlock(&irmd.reg_lock); @@ -1079,8 +1101,8 @@ static ssize_t list_names(name_info_msg_t *** names, return -ENOMEM; } - list_for_each(p, &irmd.registry) { - struct reg_entry * e = list_entry(p, struct reg_entry, next); + list_for_each(p, &irmd.names) { + struct reg_name * e = list_entry(p, struct reg_name, next); (*names)[i] = malloc(sizeof(***names)); if ((*names)[i] == NULL) { @@ -1114,21 +1136,21 @@ static ssize_t list_names(name_info_msg_t *** names, int name_reg(const char * name, pid_t pid) { - size_t len; - struct ipcp_entry * ipcp; - uint8_t * hash; - int err; + size_t len; + struct reg_ipcp * ipcp; + uint8_t * hash; + int err; assert(name); pthread_rwlock_wrlock(&irmd.reg_lock); - if (!registry_has_name(&irmd.registry, name)) { + if (!registry_has_name(name)) { err = -ENAME; goto fail; } - ipcp = get_ipcp_entry_by_pid(pid); + ipcp = registry_get_ipcp_by_pid(pid); if (ipcp == NULL) { err = -EIPCP; goto fail; @@ -1172,16 +1194,16 @@ fail: static int name_unreg(const char * name, pid_t pid) { - struct ipcp_entry * ipcp; - int err; - uint8_t * hash; - size_t len; + struct reg_ipcp * ipcp; + int err; + uint8_t * hash; + size_t len; assert(name); pthread_rwlock_wrlock(&irmd.reg_lock); - ipcp = get_ipcp_entry_by_pid(pid); + ipcp = registry_get_ipcp_by_pid(pid); if (ipcp == NULL) { err = -EIPCP; goto fail; @@ -1221,34 +1243,27 @@ static int name_unreg(const char * name, return err; } -static int proc_announce(pid_t pid, - char * prog) +static int proc_announce(pid_t pid, + const char * prog) { - struct proc_entry * e; - struct prog_entry * a; - char * prog_dup; + struct reg_proc * rpc; + struct reg_prog * rpg; assert(prog); - prog_dup = strdup(prog); - if (prog_dup == NULL) + rpc = reg_proc_create(pid, prog); + if (rpc == NULL) return -ENOMEM; - e = proc_entry_create(pid, prog_dup); - if (e == NULL) { - free(prog_dup); - return -ENOMEM; - } - pthread_rwlock_wrlock(&irmd.reg_lock); - proc_table_add(&irmd.proc_table, e); + registry_add_proc(rpc); /* Copy listen names from program if it exists. */ - a = prog_table_get(&irmd.prog_table, e->prog); - if (a != NULL) { + rpg = registry_get_prog(rpc->prog); + if (rpg != NULL) { struct list_head * p; - list_for_each(p, &a->names) { + list_for_each(p, &rpg->names) { struct str_el * s = list_entry(p, struct str_el, next); struct str_el * n = malloc(sizeof(*n)); if (n == NULL) { @@ -1263,9 +1278,9 @@ static int proc_announce(pid_t pid, return -ENOMEM; } - list_add(&n->next, &e->names); + list_add(&n->next, &rpc->names); log_dbg("Process %d inherits name %s from program %s.", - pid, n->str, e->prog); + pid, n->str, rpc->prog); } } @@ -1276,42 +1291,42 @@ static int proc_announce(pid_t pid, static int flow_accept(pid_t pid, struct timespec * dl, - struct irm_flow * f_out, + struct reg_flow * f_out, buffer_t * data) { - struct irm_flow * f; - struct proc_entry * pe; - struct reg_entry * re; - struct list_head * p; - pid_t pid_n; - pid_t pid_n_1; - int flow_id; - int ret; - buffer_t tmp = {NULL, 0}; + struct reg_flow * f; + struct reg_proc * rp; + struct reg_name * n; + struct list_head * p; + pid_t pid_n; + pid_t pid_n_1; + int flow_id; + int ret; + buffer_t tmp = {NULL, 0}; pthread_rwlock_wrlock(&irmd.reg_lock); - pe = proc_table_get(&irmd.proc_table, pid); - if (pe == NULL) { + rp = registry_get_proc(pid); + if (rp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Unknown process %d calling accept.", pid); return -EINVAL; } - log_dbg("New instance (%d) of %s added.", pid, pe->prog); + log_dbg("New instance (%d) of %s added.", pid, rp->prog); log_dbg("This process accepts flows for:"); - list_for_each(p, &pe->names) { + list_for_each(p, &rp->names) { struct str_el * s = list_entry(p, struct str_el, next); log_dbg(" %s", s->str); - re = registry_get_entry(&irmd.registry, s->str); - if (re != NULL) - reg_entry_add_pid(re, pid); + n = registry_get_name(s->str); + if (n != NULL) + reg_name_add_pid(n, pid); } pthread_rwlock_unlock(&irmd.reg_lock); - ret = proc_entry_sleep(pe, dl); + ret = reg_proc_sleep(rp, dl); if (ret == -ETIMEDOUT) return -ETIMEDOUT; @@ -1323,7 +1338,7 @@ static int flow_accept(pid_t pid, pthread_rwlock_rdlock(&irmd.flows_lock); - f = get_irm_flow_n(pid); + f = registry_get_pending_flow_for_pid(pid); if (f == NULL) { pthread_rwlock_unlock(&irmd.flows_lock); log_warn("Port_id was not created yet."); @@ -1337,42 +1352,42 @@ static int flow_accept(pid_t pid, pthread_rwlock_unlock(&irmd.flows_lock); pthread_rwlock_rdlock(&irmd.reg_lock); - pe = proc_table_get(&irmd.proc_table, pid); - if (pe == NULL) { + rp = registry_get_proc(pid); + if (rp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); pthread_rwlock_wrlock(&irmd.flows_lock); list_del(&f->next); bmp_release(irmd.flow_ids, f->flow_id); pthread_rwlock_unlock(&irmd.flows_lock); ipcp_flow_alloc_resp(pid_n_1, flow_id, pid_n, -1, tmp); - clear_irm_flow(f); - irm_flow_set_state(f, FLOW_NULL); - irm_flow_destroy(f); + clear_reg_flow(f); + reg_flow_set_state(f, FLOW_NULL); + reg_flow_destroy(f); log_dbg("Process gone while accepting flow."); return -EPERM; } - pthread_mutex_lock(&pe->lock); + pthread_mutex_lock(&rp->lock); - re = pe->re; + n = rp->name; - pthread_mutex_unlock(&pe->lock); + pthread_mutex_unlock(&rp->lock); - if (reg_entry_get_state(re) != REG_NAME_FLOW_ARRIVED) { + if (reg_name_get_state(n) != NAME_FLOW_ARRIVED) { pthread_rwlock_unlock(&irmd.reg_lock); pthread_rwlock_wrlock(&irmd.flows_lock); list_del(&f->next); bmp_release(irmd.flow_ids, f->flow_id); pthread_rwlock_unlock(&irmd.flows_lock); ipcp_flow_alloc_resp(pid_n_1, flow_id, pid_n, -1, tmp); - clear_irm_flow(f); - irm_flow_set_state(f, FLOW_NULL); - irm_flow_destroy(f); + clear_reg_flow(f); + reg_flow_set_state(f, FLOW_NULL); + reg_flow_destroy(f); log_err("Entry in wrong state."); return -EPERM; } - registry_del_process(&irmd.registry, pid); + registry_names_del_proc(pid); pthread_rwlock_unlock(&irmd.reg_lock); @@ -1397,13 +1412,13 @@ static int flow_accept(pid_t pid, list_del(&f->next); pthread_rwlock_unlock(&irmd.flows_lock); log_dbg("Failed to respond to alloc. Port_id invalidated."); - clear_irm_flow(f); - irm_flow_set_state(f, FLOW_NULL); - irm_flow_destroy(f); + clear_reg_flow(f); + reg_flow_set_state(f, FLOW_NULL); + reg_flow_destroy(f); return -EPERM; } - irm_flow_set_state(f, FLOW_ALLOCATED); + reg_flow_set_state(f, FLOW_ALLOCATED); log_info("Flow on flow_id %d allocated.", f->flow_id); @@ -1414,17 +1429,17 @@ static int flow_join(pid_t pid, const char * dst, qosspec_t qs, struct timespec * dl, - struct irm_flow * f_out) + struct reg_flow * f_out) { - struct irm_flow * f; - struct ipcp_entry * ipcp; + struct reg_flow * f; + struct reg_ipcp * ipcp; int flow_id; int state; uint8_t * hash; log_info("Allocating flow for %d to %s.", pid, dst); - ipcp = get_ipcp_entry_by_layer(dst); + ipcp = registry_get_ipcp_by_layer(dst); if (ipcp == NULL) { log_info("Layer %s unreachable.", dst); return -1; @@ -1439,7 +1454,7 @@ static int flow_join(pid_t pid, return -EBADF; } - f = irm_flow_create(pid, ipcp->pid, flow_id, qs); + f = reg_flow_create(pid, ipcp->pid, flow_id, qs); if (f == NULL) { bmp_release(irmd.flow_ids, flow_id); pthread_rwlock_unlock(&irmd.flows_lock); @@ -1447,11 +1462,11 @@ static int flow_join(pid_t pid, return -ENOMEM; } - list_add(&f->next, &irmd.irm_flows); + list_add(&f->next, &irmd.flows); pthread_rwlock_unlock(&irmd.flows_lock); - assert(irm_flow_get_state(f) == FLOW_ALLOC_PENDING); + assert(reg_flow_get_state(f) == FLOW_ALLOC_PENDING); hash = malloc(IPCP_HASH_LEN(ipcp)); if (hash == NULL) @@ -1462,7 +1477,7 @@ static int flow_join(pid_t pid, if (ipcp_flow_join(ipcp->pid, flow_id, pid, hash, IPCP_HASH_LEN(ipcp), qs)) { - irm_flow_set_state(f, FLOW_NULL); + reg_flow_set_state(f, FLOW_NULL); /* sanitizer cleans this */ log_info("Flow_join failed."); free(hash); @@ -1471,7 +1486,7 @@ static int flow_join(pid_t pid, free(hash); - state = irm_flow_wait_state(f, FLOW_ALLOCATED, dl); + state = reg_flow_wait_state(f, FLOW_ALLOCATED, dl); if (state != FLOW_ALLOCATED) { if (state == -ETIMEDOUT) { log_dbg("Flow allocation timed out"); @@ -1484,7 +1499,7 @@ static int flow_join(pid_t pid, pthread_rwlock_wrlock(&irmd.flows_lock); - assert(irm_flow_get_state(f) == FLOW_ALLOCATED); + assert(reg_flow_get_state(f) == FLOW_ALLOCATED); f_out->flow_id = f->flow_id; f_out->n_pid = f->n_pid; @@ -1505,18 +1520,18 @@ static int flow_alloc(pid_t pid, const char * dst, qosspec_t qs, struct timespec * dl, - struct irm_flow * f_out, + struct reg_flow * f_out, buffer_t * data) { - struct irm_flow * f; - struct ipcp_entry * ipcp; + struct reg_flow * f; + struct reg_ipcp * ipcp; int flow_id; int state; uint8_t * hash; log_info("Allocating flow for %d to %s.", pid, dst); - ipcp = get_ipcp_by_dst_name(dst, pid); + ipcp = registry_get_ipcp_by_dst_name(dst, pid); if (ipcp == NULL) { log_info("Destination %s unreachable.", dst); return -1; @@ -1531,7 +1546,7 @@ static int flow_alloc(pid_t pid, return -EBADF; } - f = irm_flow_create(pid, ipcp->pid, flow_id, qs); + f = reg_flow_create(pid, ipcp->pid, flow_id, qs); if (f == NULL) { bmp_release(irmd.flow_ids, flow_id); pthread_rwlock_unlock(&irmd.flows_lock); @@ -1539,11 +1554,11 @@ static int flow_alloc(pid_t pid, return -ENOMEM; } - list_add(&f->next, &irmd.irm_flows); + list_add(&f->next, &irmd.flows); pthread_rwlock_unlock(&irmd.flows_lock); - assert(irm_flow_get_state(f) == FLOW_ALLOC_PENDING); + assert(reg_flow_get_state(f) == FLOW_ALLOC_PENDING); hash = malloc(IPCP_HASH_LEN(ipcp)); if (hash == NULL) @@ -1554,7 +1569,7 @@ static int flow_alloc(pid_t pid, if (ipcp_flow_alloc(ipcp->pid, flow_id, pid, hash, IPCP_HASH_LEN(ipcp), qs, *data)) { - irm_flow_set_state(f, FLOW_NULL); + reg_flow_set_state(f, FLOW_NULL); /* sanitizer cleans this */ log_info("Flow_allocation failed."); free(hash); @@ -1563,7 +1578,7 @@ static int flow_alloc(pid_t pid, free(hash); - state = irm_flow_wait_state(f, FLOW_ALLOCATED, dl); + state = reg_flow_wait_state(f, FLOW_ALLOCATED, dl); if (state != FLOW_ALLOCATED) { if (state == -ETIMEDOUT) { log_dbg("Flow allocation timed out"); @@ -1576,7 +1591,7 @@ static int flow_alloc(pid_t pid, pthread_rwlock_wrlock(&irmd.flows_lock); - assert(irm_flow_get_state(f) == FLOW_ALLOCATED); + assert(reg_flow_get_state(f) == FLOW_ALLOCATED); f_out->flow_id = f->flow_id; f_out->n_pid = f->n_pid; @@ -1599,14 +1614,14 @@ static int flow_dealloc(pid_t pid, pid_t n_1_pid = -1; int ret = 0; - struct irm_flow * f = NULL; + struct reg_flow * f = NULL; log_dbg("Deallocating flow %d for process %d.", flow_id, pid); pthread_rwlock_wrlock(&irmd.flows_lock); - f = get_irm_flow(flow_id); + f = registry_get_flow(flow_id); if (f == NULL) { pthread_rwlock_unlock(&irmd.flows_lock); log_dbg("Deallocate unknown port %d by %d.", flow_id, pid); @@ -1624,18 +1639,18 @@ static int flow_dealloc(pid_t pid, return -EPERM; } - if (irm_flow_get_state(f) == FLOW_DEALLOC_PENDING) { + if (reg_flow_get_state(f) == FLOW_DEALLOC_PENDING) { list_del(&f->next); if ((kill(f->n_pid, 0) < 0 && f->n_1_pid == -1) || (kill(f->n_1_pid, 0) < 0 && f->n_pid == -1)) - irm_flow_set_state(f, FLOW_NULL); - clear_irm_flow(f); - irm_flow_destroy(f); + reg_flow_set_state(f, FLOW_NULL); + clear_reg_flow(f); + reg_flow_destroy(f); bmp_release(irmd.flow_ids, flow_id); log_info("Completed deallocation of flow_id %d by process %d.", flow_id, pid); } else { - irm_flow_set_state(f, FLOW_DEALLOC_PENDING); + reg_flow_set_state(f, FLOW_DEALLOC_PENDING); log_dbg("Partial deallocation of flow_id %d by process %d.", flow_id, pid); } @@ -1674,77 +1689,76 @@ static pid_t auto_execute(char ** argv) } static int flow_req_arr(pid_t pid, - struct irm_flow * f_out, + struct reg_flow * f_out, const uint8_t * hash, time_t mpl, qosspec_t qs, buffer_t data) { - struct reg_entry * re; - struct prog_entry * a; - struct proc_entry * pe; - struct irm_flow * f; - - struct pid_el * c_pid; - struct ipcp_entry * ipcp; - pid_t h_pid; - int flow_id; + struct reg_name * n; + struct reg_prog * rpg; + struct reg_proc * rpc; + struct reg_flow * f; + struct reg_ipcp * ipcp; - struct timespec wt = {IRMD_REQ_ARR_TIMEOUT / 1000, - (IRMD_REQ_ARR_TIMEOUT % 1000) * MILLION}; + struct pid_el * c_pid; + pid_t h_pid; + int flow_id; + + struct timespec wt = {IRMD_REQ_ARR_TIMEOUT / 1000, + (IRMD_REQ_ARR_TIMEOUT % 1000) * MILLION}; log_dbg("Flow req arrived from IPCP %d for " HASH_FMT ".", pid, HASH_VAL(hash)); pthread_rwlock_rdlock(&irmd.reg_lock); - ipcp = get_ipcp_entry_by_pid(pid); + ipcp = registry_get_ipcp_by_pid(pid); if (ipcp == NULL) { log_err("IPCP died."); return -EIPCP; } - re = registry_get_entry_by_hash(&irmd.registry, ipcp->dir_hash_algo, - hash, IPCP_HASH_LEN(ipcp)); - if (re == NULL) { + n = registry_get_name_by_hash(ipcp->dir_hash_algo, + hash, IPCP_HASH_LEN(ipcp)); + if (n == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Unknown hash: " HASH_FMT ".", HASH_VAL(hash)); return -1; } - log_info("Flow request arrived for %s.", re->name); + log_info("Flow request arrived for %s.", n->name); pthread_rwlock_unlock(&irmd.reg_lock); /* Give the process a bit of slop time to call accept */ - if (reg_entry_leave_state(re, REG_NAME_IDLE, &wt) == -1) { + if (reg_name_leave_state(n, NAME_IDLE, &wt) == -1) { log_err("No processes for " HASH_FMT ".", HASH_VAL(hash)); return -1; } pthread_rwlock_wrlock(&irmd.reg_lock); - switch (reg_entry_get_state(re)) { - case REG_NAME_IDLE: + switch (reg_name_get_state(n)) { + case NAME_IDLE: pthread_rwlock_unlock(&irmd.reg_lock); log_err("No processes for " HASH_FMT ".", HASH_VAL(hash)); return -1; - case REG_NAME_AUTO_ACCEPT: + case NAME_AUTO_ACCEPT: c_pid = malloc(sizeof(*c_pid)); if (c_pid == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); return -1; } - reg_entry_set_state(re, REG_NAME_AUTO_EXEC); - a = prog_table_get(&irmd.prog_table, - reg_entry_get_prog(re)); - - if (a == NULL || (c_pid->pid = auto_execute(a->argv)) < 0) { - reg_entry_set_state(re, REG_NAME_AUTO_ACCEPT); + reg_name_set_state(n, NAME_AUTO_EXEC); + rpg = registry_get_prog(reg_name_get_prog(n)); + if (rpg == NULL + || (c_pid->pid = auto_execute(rpg->argv)) < 0) { + reg_name_set_state(n, NAME_AUTO_ACCEPT); pthread_rwlock_unlock(&irmd.reg_lock); log_err("Could not start program for reg_entry %s.", - re->name); + n->name); free(c_pid); return -1; } @@ -1753,13 +1767,13 @@ static int flow_req_arr(pid_t pid, pthread_rwlock_unlock(&irmd.reg_lock); - if (reg_entry_leave_state(re, REG_NAME_AUTO_EXEC, NULL)) + if (reg_name_leave_state(n, NAME_AUTO_EXEC, NULL)) return -1; pthread_rwlock_wrlock(&irmd.reg_lock); /* FALLTHRU */ - case REG_NAME_FLOW_ACCEPT: - h_pid = reg_entry_get_pid(re); + case NAME_FLOW_ACCEPT: + h_pid = reg_name_get_pid(n); if (h_pid == -1) { pthread_rwlock_unlock(&irmd.reg_lock); log_err("Invalid process id returned."); @@ -1782,7 +1796,7 @@ static int flow_req_arr(pid_t pid, return -1; } - f = irm_flow_create(h_pid, pid, flow_id, qs); + f = reg_flow_create(h_pid, pid, flow_id, qs); if (f == NULL) { bmp_release(irmd.flow_ids, flow_id); pthread_rwlock_unlock(&irmd.flows_lock); @@ -1794,32 +1808,32 @@ static int flow_req_arr(pid_t pid, f->mpl = mpl; f->data = data; - list_add(&f->next, &irmd.irm_flows); + list_add(&f->next, &irmd.flows); pthread_rwlock_unlock(&irmd.flows_lock); pthread_rwlock_rdlock(&irmd.reg_lock); - reg_entry_set_state(re, REG_NAME_FLOW_ARRIVED); + reg_name_set_state(n, NAME_FLOW_ARRIVED); - pe = proc_table_get(&irmd.proc_table, h_pid); - if (pe == NULL) { + rpc = registry_get_proc(h_pid); + if (rpc == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); pthread_rwlock_wrlock(&irmd.flows_lock); - clear_irm_flow(f); + clear_reg_flow(f); bmp_release(irmd.flow_ids, f->flow_id); list_del(&f->next); pthread_rwlock_unlock(&irmd.flows_lock); log_err("Could not get process table entry for %d.", h_pid); freebuf(f->data); - irm_flow_destroy(f); + reg_flow_destroy(f); return -1; } - proc_entry_wake(pe, re); + reg_proc_wake(rpc, n); pthread_rwlock_unlock(&irmd.reg_lock); - reg_entry_leave_state(re, REG_NAME_FLOW_ARRIVED, NULL); + reg_name_leave_state(n, NAME_FLOW_ARRIVED, NULL); f_out->flow_id = flow_id; f_out->n_pid = h_pid; @@ -1832,10 +1846,11 @@ static int flow_alloc_reply(int flow_id, time_t mpl, buffer_t data) { - struct irm_flow * f; + struct reg_flow * f; pthread_rwlock_wrlock(&irmd.flows_lock); - f = get_irm_flow(flow_id); + + f = registry_get_flow(flow_id); if (f == NULL) { pthread_rwlock_unlock(&irmd.flows_lock); return -1; @@ -1844,9 +1859,9 @@ static int flow_alloc_reply(int flow_id, f->mpl = mpl; if (!response) - irm_flow_set_state(f, FLOW_ALLOCATED); + reg_flow_set_state(f, FLOW_ALLOCATED); else - irm_flow_set_state(f, FLOW_NULL); + reg_flow_set_state(f, FLOW_NULL); f->data = data; @@ -1887,31 +1902,31 @@ void * irm_sanitize(void * o) free(e); } - list_for_each_safe(p, h, &irmd.proc_table) { - struct proc_entry * e = - list_entry(p, struct proc_entry, next); + list_for_each_safe(p, h, &irmd.procs) { + struct reg_proc * e = + list_entry(p, struct reg_proc, next); if (kill(e->pid, 0) >= 0) continue; log_dbg("Dead process removed: %d.", e->pid); list_del(&e->next); - proc_entry_destroy(e); + reg_proc_destroy(e); } list_for_each_safe(p, h, &irmd.ipcps) { - struct ipcp_entry * e = - list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = + list_entry(p, struct reg_ipcp, next); if (kill(e->pid, 0) >= 0) continue; log_dbg("Dead IPCP removed: %d.", e->pid); list_del(&e->next); - ipcp_entry_destroy(e); + reg_ipcp_destroy(e); } - list_for_each_safe(p, h, &irmd.registry) { + list_for_each_safe(p, h, &irmd.names) { struct list_head * p2; struct list_head * h2; - struct reg_entry * e = - list_entry(p, struct reg_entry, next); + struct reg_name * e = + list_entry(p, struct reg_name, next); list_for_each_safe(p2, h2, &e->reg_pids) { struct pid_el * a = list_entry(p2, struct pid_el, next); @@ -1919,7 +1934,7 @@ void * irm_sanitize(void * o) continue; log_dbg("Dead process removed from: %d %s.", a->pid, e->name); - reg_entry_del_pid_el(e, a); + reg_name_del_pid_el(e, a); } } @@ -1928,18 +1943,18 @@ void * irm_sanitize(void * o) pthread_rwlock_wrlock(&irmd.flows_lock); pthread_cleanup_push(__cleanup_rwlock_unlock, &irmd.flows_lock); - list_for_each_safe(p, h, &irmd.irm_flows) { + list_for_each_safe(p, h, &irmd.flows) { int ipcpi; int flow_id; - struct irm_flow * f = - list_entry(p, struct irm_flow, next); + struct reg_flow * f = + list_entry(p, struct reg_flow, next); - if (irm_flow_get_state(f) == FLOW_ALLOC_PENDING + if (reg_flow_get_state(f) == FLOW_ALLOC_PENDING && ts_diff_ms(&f->t0, &now) > IRMD_FLOW_TIMEOUT) { log_dbg("Pending flow_id %d timed out.", f->flow_id); f->n_pid = -1; - irm_flow_set_state(f, FLOW_DEALLOC_PENDING); + reg_flow_set_state(f, FLOW_DEALLOC_PENDING); continue; } @@ -1948,7 +1963,7 @@ void * irm_sanitize(void * o) "flow %d.", f->n_pid, f->flow_id); f->n_pid = -1; - irm_flow_set_state(f, FLOW_DEALLOC_PENDING); + reg_flow_set_state(f, FLOW_DEALLOC_PENDING); ipcpi = f->n_1_pid; flow_id = f->flow_id; ipcp_flow_dealloc(ipcpi, flow_id, DEALLOC_TIME); @@ -1963,7 +1978,7 @@ void * irm_sanitize(void * o) if (set != NULL) shm_flow_set_destroy(set); f->n_1_pid = -1; - irm_flow_set_state(f, FLOW_DEALLOC_PENDING); + reg_flow_set_state(f, FLOW_DEALLOC_PENDING); } } @@ -2038,7 +2053,7 @@ static void * mainloop(void * o) while (true) { irm_msg_t * ret_msg; - struct irm_flow f; + struct reg_flow f; struct ipcp_config conf; struct timespec * dl = NULL; struct timespec ts = {0, 0}; @@ -2326,9 +2341,9 @@ static void irm_fini(void) /* Clear the lists. */ list_for_each_safe(p, h, &irmd.ipcps) { - struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); + struct reg_ipcp * e = list_entry(p, struct reg_ipcp, next); list_del(&e->next); - ipcp_entry_destroy(e); + reg_ipcp_destroy(e); } list_for_each(p, &irmd.spawned_pids) { @@ -2343,24 +2358,24 @@ static void irm_fini(void) if (waitpid(e->pid, &status, 0) < 0) log_dbg("Error waiting for %d to exit.", e->pid); list_del(&e->next); - registry_del_process(&irmd.registry, e->pid); + registry_names_del_proc(e->pid); free(e); } - list_for_each_safe(p, h, &irmd.prog_table) { - struct prog_entry * e = list_entry(p, struct prog_entry, next); + list_for_each_safe(p, h, &irmd.progs) { + struct reg_prog * e = list_entry(p, struct reg_prog, next); list_del(&e->next); - prog_entry_destroy(e); + reg_prog_destroy(e); } - list_for_each_safe(p, h, &irmd.proc_table) { - struct proc_entry * e = list_entry(p, struct proc_entry, next); + list_for_each_safe(p, h, &irmd.procs) { + struct reg_proc * e = list_entry(p, struct reg_proc, next); list_del(&e->next); e->state = PROC_INIT; /* sanitizer already joined */ - proc_entry_destroy(e); + reg_proc_destroy(e); } - registry_destroy(&irmd.registry); + registry_destroy_names(); pthread_rwlock_unlock(&irmd.reg_lock); @@ -2374,10 +2389,10 @@ static void irm_fini(void) if (irmd.flow_ids != NULL) bmp_destroy(irmd.flow_ids); - list_for_each_safe(p, h, &irmd.irm_flows) { - struct irm_flow * f = list_entry(p, struct irm_flow, next); + list_for_each_safe(p, h, &irmd.flows) { + struct reg_flow * f = list_entry(p, struct reg_flow, next); list_del(&f->next); - irm_flow_destroy(f); + reg_flow_destroy(f); } pthread_rwlock_unlock(&irmd.flows_lock); @@ -2450,11 +2465,11 @@ static int irm_init(void) pthread_condattr_destroy(&cattr); list_head_init(&irmd.ipcps); - list_head_init(&irmd.proc_table); - list_head_init(&irmd.prog_table); + list_head_init(&irmd.procs); + list_head_init(&irmd.progs); list_head_init(&irmd.spawned_pids); - list_head_init(&irmd.registry); - list_head_init(&irmd.irm_flows); + list_head_init(&irmd.names); + list_head_init(&irmd.flows); list_head_init(&irmd.cmds); irmd.flow_ids = bmp_create(SYS_MAX_FLOWS, 0); diff --git a/src/irmd/proc_table.c b/src/irmd/proc_table.c deleted file mode 100644 index ee87813d..00000000 --- a/src/irmd/proc_table.c +++ /dev/null @@ -1,297 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2023 - * - * The IPC Resource Manager - Process Table - * - * Dimitri Staessens <dimitri@ouroboros.rocks> - * Sander Vrijders <sander@ouroboros.rocks> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., http://www.fsf.org/about/contact/. - */ - -#if defined(__linux__) || defined(__CYGWIN__) -#define _DEFAULT_SOURCE -#else -#define _POSIX_C_SOURCE 200112L -#endif - -#include "config.h" - -#include <ouroboros/list.h> -#include <ouroboros/errno.h> -#include <ouroboros/time_utils.h> - -#include "proc_table.h" -#include "registry.h" - -#include <stdlib.h> -#include <unistd.h> -#include <limits.h> -#include <assert.h> - -struct proc_entry * proc_entry_create(pid_t pid, - char * prog) -{ - struct proc_entry * e; - pthread_condattr_t cattr; - - assert(prog); - - e = malloc(sizeof(*e)); - if (e == NULL) - goto fail_malloc; - - if (pthread_condattr_init(&cattr)) - goto fail_condattr; - -#ifndef __APPLE__ - pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); -#endif - - if (pthread_mutex_init(&e->lock, NULL)) - goto fail_mutex; - - if (pthread_cond_init(&e->cond, &cattr)) - goto fail_cond; - - e->set = shm_flow_set_create(pid); - if (e->set == NULL) - goto fail_set; - - list_head_init(&e->next); - list_head_init(&e->names); - - e->pid = pid; - e->prog = prog; - e->re = NULL; - e->state = PROC_INIT; - - return e; - fail_set: - pthread_cond_destroy(&e->cond);; - fail_cond: - pthread_mutex_destroy(&e->lock); - fail_mutex: - pthread_condattr_destroy(&cattr); - fail_condattr: - free(e); - fail_malloc: - return NULL; -} - -static void cancel_proc_entry(void * o) -{ - struct proc_entry * e = (struct proc_entry *) o; - - e->state = PROC_NULL; - - pthread_mutex_unlock(&e->lock); -} - -void proc_entry_destroy(struct proc_entry * e) -{ - struct list_head * p; - struct list_head * h; - - assert(e); - - pthread_mutex_lock(&e->lock); - - if (e->state == PROC_DESTROY) { - pthread_mutex_unlock(&e->lock); - return; - } - - if (e->state == PROC_SLEEP) - e->state = PROC_DESTROY; - - pthread_cond_signal(&e->cond); - - pthread_cleanup_push(cancel_proc_entry, e); - - while (e->state != PROC_INIT) - pthread_cond_wait(&e->cond, &e->lock); - - pthread_cleanup_pop(false); - - pthread_mutex_unlock(&e->lock); - - shm_flow_set_destroy(e->set); - - pthread_cond_destroy(&e->cond); - pthread_mutex_destroy(&e->lock); - - if (e->prog != NULL) - free(e->prog); - - list_for_each_safe(p, h, &e->names) { - struct str_el * n = list_entry(p, struct str_el, next); - list_del(&n->next); - if (n->str != NULL) - free(n->str); - free(n); - } - - free(e); -} - -int proc_entry_add_name(struct proc_entry * e, - char * name) -{ - struct str_el * s; - - assert(e); - assert(name); - - s = malloc(sizeof(*s)); - if (s == NULL) - return -ENOMEM; - - s->str = name; - list_add(&s->next, &e->names); - - return 0; -} - -void proc_entry_del_name(struct proc_entry * e, - const char * name) -{ - struct list_head * p = NULL; - struct list_head * h = NULL; - - assert(e); - assert(name); - - list_for_each_safe(p, h, &e->names) { - struct str_el * s = list_entry(p, struct str_el, next); - if (!strcmp(name, s->str)) { - list_del(&s->next); - free(s->str); - free(s); - } - } -} - -int proc_entry_sleep(struct proc_entry * e, - struct timespec * dl) -{ - - int ret = 0; - - assert(e); - - pthread_mutex_lock(&e->lock); - - if (e->state != PROC_WAKE && e->state != PROC_DESTROY) - e->state = PROC_SLEEP; - - pthread_cleanup_push(cancel_proc_entry, e); - - while (e->state == PROC_SLEEP && ret != -ETIMEDOUT) - if (dl != NULL) - ret = -pthread_cond_timedwait(&e->cond, &e->lock, dl); - else - ret = -pthread_cond_wait(&e->cond, &e->lock); - - pthread_cleanup_pop(false); - - if (e->state == PROC_DESTROY) { - if (e->re != NULL) - reg_entry_del_pid(e->re, e->pid); - ret = -1; - } - - e->state = PROC_INIT; - - pthread_cond_broadcast(&e->cond); - pthread_mutex_unlock(&e->lock); - - return ret; -} - -void proc_entry_wake(struct proc_entry * e, - struct reg_entry * re) -{ - assert(e); - assert(re); - - pthread_mutex_lock(&e->lock); - - if (e->state != PROC_SLEEP) { - pthread_mutex_unlock(&e->lock); - return; - } - - e->state = PROC_WAKE; - e->re = re; - - pthread_cond_broadcast(&e->cond); - - pthread_cleanup_push(cancel_proc_entry, e); - - while (e->state == PROC_WAKE) - pthread_cond_wait(&e->cond, &e->lock); - - pthread_cleanup_pop(false); - - if (e->state == PROC_DESTROY) - e->state = PROC_INIT; - - pthread_mutex_unlock(&e->lock); -} - -int proc_table_add(struct list_head * proc_table, - struct proc_entry * e) -{ - - assert(proc_table); - assert(e); - - list_add(&e->next, proc_table); - - return 0; -} - -void proc_table_del(struct list_head * proc_table, - pid_t pid) -{ - struct list_head * p; - struct list_head * h; - - assert(proc_table); - - list_for_each_safe(p, h, proc_table) { - struct proc_entry * e = list_entry(p, struct proc_entry, next); - if (pid == e->pid) { - list_del(&e->next); - proc_entry_destroy(e); - } - } -} - -struct proc_entry * proc_table_get(struct list_head * proc_table, - pid_t pid) -{ - struct list_head * h; - - assert(proc_table); - - list_for_each(h, proc_table) { - struct proc_entry * e = list_entry(h, struct proc_entry, next); - if (pid == e->pid) - return e; - } - - return NULL; -} diff --git a/src/irmd/prog_table.c b/src/irmd/prog_table.c deleted file mode 100644 index 0faedf0d..00000000 --- a/src/irmd/prog_table.c +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2023 - * - * The IPC Resource Manager - Program Table - * - * Dimitri Staessens <dimitri@ouroboros.rocks> - * Sander Vrijders <sander@ouroboros.rocks> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., http://www.fsf.org/about/contact/. - */ - -#include <ouroboros/errno.h> -#include <ouroboros/irm.h> - -#include "prog_table.h" -#include "utils.h" - -#include <assert.h> -#include <stdlib.h> -#include <string.h> - -struct prog_entry * prog_entry_create(char * prog, - uint32_t flags, - char ** argv) -{ - struct prog_entry * e; - - assert(prog); - - e = malloc(sizeof(*e)); - if (e == NULL) - return NULL; - - list_head_init(&e->next); - list_head_init(&e->names); - - e->prog = prog; - e->flags = flags; - - if (flags & BIND_AUTO) { - e->argv = argv; - } else { - e->argv = NULL; - argvfree(argv); - argv = NULL; - } - - return e; -} -void prog_entry_destroy(struct prog_entry * e) -{ - struct list_head * p = NULL; - struct list_head * h = NULL; - - if (e == NULL) - return; - - if (e->prog != NULL) - free(e->prog); - - if (e->argv != NULL) - argvfree(e->argv); - - list_for_each_safe(p, h, &e->names) { - struct str_el * s = list_entry(p, struct str_el, next); - list_del(&s->next); - free(s->str); - free(s); - } - - free(e); -} - -int prog_entry_add_name(struct prog_entry * e, - char * name) -{ - struct str_el * s; - - if (e == NULL || name == NULL) - return -EINVAL; - - s = malloc(sizeof(*s)); - if (s == NULL) - return -ENOMEM; - - s->str = name; - list_add(&s->next, &e->names); - - return 0; -} - -void prog_entry_del_name(struct prog_entry * e, - char * name) -{ - struct list_head * p = NULL; - struct list_head * h = NULL; - - list_for_each_safe(p, h, &e->names) { - struct str_el * s = list_entry(p, struct str_el, next); - if (!strcmp(name, s->str)) { - list_del(&s->next); - free(s->str); - free(s); - } - } -} - -int prog_table_add(struct list_head * prog_table, - struct prog_entry * e) -{ - assert(prog_table); - assert(e); - - list_add(&e->next, prog_table); - - return 0; -} - -void prog_table_del(struct list_head * prog_table, - char * prog) -{ - struct list_head * p; - struct list_head * h; - - assert(prog_table); - assert(prog); - - list_for_each_safe(p, h, prog_table) { - struct prog_entry * e = list_entry(p, struct prog_entry, next); - if (!strcmp(prog, e->prog)) { - list_del(&e->next); - prog_entry_destroy(e); - } - } -} - -struct prog_entry * prog_table_get(struct list_head * prog_table, - char * prog) -{ - struct list_head * p; - - assert(prog_table); - assert(prog); - - list_for_each(p, prog_table) { - struct prog_entry * e = list_entry(p, struct prog_entry, next); - if (!strcmp(e->prog, prog)) - return e; - } - - return NULL; -} diff --git a/src/irmd/irm_flow.c b/src/irmd/reg/flow.c index 6d22cbc8..30b9c504 100644 --- a/src/irmd/irm_flow.c +++ b/src/irmd/reg/flow.c @@ -1,7 +1,7 @@ /* * Ouroboros - Copyright (C) 2016 - 2023 * - * The IPC Resource Manager - Flows + * The IPC Resource Manager - Registry - Flows * * Dimitri Staessens <dimitri@ouroboros.rocks> * Sander Vrijders <sander@ouroboros.rocks> @@ -24,27 +24,27 @@ #include "config.h" -#define OUROBOROS_PREFIX "irm_flow" +#define OUROBOROS_PREFIX "reg-flow" #include <ouroboros/errno.h> #include <ouroboros/logs.h> #include <ouroboros/time_utils.h> #include <ouroboros/pthread.h> -#include "irm_flow.h" +#include "flow.h" #include <assert.h> #include <stdbool.h> #include <stdlib.h> #include <string.h> -struct irm_flow * irm_flow_create(pid_t n_pid, +struct reg_flow * reg_flow_create(pid_t n_pid, pid_t n_1_pid, int flow_id, qosspec_t qs) { pthread_condattr_t cattr; - struct irm_flow * f; + struct reg_flow * f; f = malloc(sizeof(*f)); if (f == NULL) @@ -58,10 +58,10 @@ struct irm_flow * irm_flow_create(pid_t n_pid, #ifndef __APPLE__ pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); #endif - if (pthread_cond_init(&f->state_cond, &cattr)) - goto fail_state_cond; + if (pthread_cond_init(&f->cond, &cattr)) + goto fail_cond; - if (pthread_mutex_init(&f->state_lock, NULL)) + if (pthread_mutex_init(&f->mtx, NULL)) goto fail_mutex; f->n_rb = shm_rbuff_create(n_pid, flow_id); @@ -79,6 +79,8 @@ struct irm_flow * irm_flow_create(pid_t n_pid, if (clock_gettime(CLOCK_MONOTONIC, &f->t0) < 0) log_warn("Failed to set timestamp."); + pthread_condattr_destroy(&cattr); + f->n_pid = n_pid; f->n_1_pid = n_1_pid; f->flow_id = flow_id; @@ -86,17 +88,15 @@ struct irm_flow * irm_flow_create(pid_t n_pid, f->state = FLOW_ALLOC_PENDING; - pthread_condattr_destroy(&cattr); - return f; fail_n_1_rbuff: shm_rbuff_destroy(f->n_rb); fail_n_rbuff: - pthread_mutex_destroy(&f->state_lock); + pthread_mutex_destroy(&f->mtx); fail_mutex: - pthread_cond_destroy(&f->state_cond); - fail_state_cond: + pthread_cond_destroy(&f->cond); + fail_cond: pthread_condattr_destroy(&cattr); fail_cattr: free(f); @@ -106,12 +106,12 @@ struct irm_flow * irm_flow_create(pid_t n_pid, static void cancel_irm_destroy(void * o) { - struct irm_flow * f = (struct irm_flow *) o; + struct reg_flow * f = (struct reg_flow *) o; - pthread_mutex_unlock(&f->state_lock); + pthread_mutex_unlock(&f->mtx); - pthread_cond_destroy(&f->state_cond); - pthread_mutex_destroy(&f->state_lock); + pthread_cond_destroy(&f->cond); + pthread_mutex_destroy(&f->mtx); shm_rbuff_destroy(f->n_rb); shm_rbuff_destroy(f->n_1_rb); @@ -119,16 +119,16 @@ static void cancel_irm_destroy(void * o) free(f); } -void irm_flow_destroy(struct irm_flow * f) +void reg_flow_destroy(struct reg_flow * f) { assert(f); - pthread_mutex_lock(&f->state_lock); + pthread_mutex_lock(&f->mtx); assert(f->data.len == 0); if (f->state == FLOW_DESTROY) { - pthread_mutex_unlock(&f->state_lock); + pthread_mutex_unlock(&f->mtx); return; } @@ -137,46 +137,46 @@ void irm_flow_destroy(struct irm_flow * f) else f->state = FLOW_NULL; - pthread_cond_broadcast(&f->state_cond); + pthread_cond_broadcast(&f->cond); pthread_cleanup_push(cancel_irm_destroy, f); while (f->state != FLOW_NULL) - pthread_cond_wait(&f->state_cond, &f->state_lock); + pthread_cond_wait(&f->cond, &f->mtx); pthread_cleanup_pop(true); } -enum flow_state irm_flow_get_state(struct irm_flow * f) +enum flow_state reg_flow_get_state(struct reg_flow * f) { enum flow_state state; assert(f); - pthread_mutex_lock(&f->state_lock); + pthread_mutex_lock(&f->mtx); state = f->state; - pthread_mutex_unlock(&f->state_lock); + pthread_mutex_unlock(&f->mtx); return state; } -void irm_flow_set_state(struct irm_flow * f, +void reg_flow_set_state(struct reg_flow * f, enum flow_state state) { assert(f); assert(state != FLOW_DESTROY); - pthread_mutex_lock(&f->state_lock); + pthread_mutex_lock(&f->mtx); f->state = state; - pthread_cond_broadcast(&f->state_cond); + pthread_cond_broadcast(&f->cond); - pthread_mutex_unlock(&f->state_lock); + pthread_mutex_unlock(&f->mtx); } -int irm_flow_wait_state(struct irm_flow * f, +int reg_flow_wait_state(struct reg_flow * f, enum flow_state state, struct timespec * dl) { @@ -188,30 +188,30 @@ int irm_flow_wait_state(struct irm_flow * f, assert(state != FLOW_DESTROY); assert(state != FLOW_DEALLOC_PENDING); - pthread_mutex_lock(&f->state_lock); + pthread_mutex_lock(&f->mtx); assert(f->state != FLOW_NULL); - pthread_cleanup_push(__cleanup_mutex_unlock, &f->state_lock); + pthread_cleanup_push(__cleanup_mutex_unlock, &f->mtx); while (!(f->state == state || f->state == FLOW_DESTROY || f->state == FLOW_DEALLOC_PENDING) && ret != -ETIMEDOUT) { if (dl != NULL) - ret = -pthread_cond_timedwait(&f->state_cond, - &f->state_lock, + ret = -pthread_cond_timedwait(&f->cond, + &f->mtx, dl); else - ret = -pthread_cond_wait(&f->state_cond, - &f->state_lock); + ret = -pthread_cond_wait(&f->cond, + &f->mtx); } if (f->state == FLOW_DESTROY || f->state == FLOW_DEALLOC_PENDING || ret == -ETIMEDOUT) { f->state = FLOW_NULL; - pthread_cond_broadcast(&f->state_cond); + pthread_cond_broadcast(&f->cond); } s = f->state; diff --git a/src/irmd/irm_flow.h b/src/irmd/reg/flow.h index a1794f5f..9af15032 100644 --- a/src/irmd/irm_flow.h +++ b/src/irmd/reg/flow.h @@ -1,7 +1,7 @@ /* * Ouroboros - Copyright (C) 2016 - 2023 * - * The IPC Resource Manager - Flows + * The IPC Resource Manager - Registry - Flows * * Dimitri Staessens <dimitri@ouroboros.rocks> * Sander Vrijders <sander@ouroboros.rocks> @@ -20,8 +20,8 @@ * Foundation, Inc., http://www.fsf.org/about/contact/. */ -#ifndef OUROBOROS_IRMD_IRM_FLOW_H -#define OUROBOROS_IRMD_IRM_FLOW_H +#ifndef OUROBOROS_IRMD_REG_FLOW_H +#define OUROBOROS_IRMD_REG_FLOW_H #include <ouroboros/list.h> #include <ouroboros/qos.h> @@ -41,7 +41,7 @@ enum flow_state { FLOW_DESTROY }; -struct irm_flow { +struct reg_flow { struct list_head next; int flow_id; @@ -59,25 +59,25 @@ struct irm_flow { struct timespec t0; enum flow_state state; - pthread_cond_t state_cond; - pthread_mutex_t state_lock; + pthread_cond_t cond; + pthread_mutex_t mtx; }; -struct irm_flow * irm_flow_create(pid_t n_pid, +struct reg_flow * reg_flow_create(pid_t n_pid, pid_t n_1_pid, int flow_id, qosspec_t qs); -void irm_flow_destroy(struct irm_flow * f); +void reg_flow_destroy(struct reg_flow * f); -enum flow_state irm_flow_get_state(struct irm_flow * f); +enum flow_state reg_flow_get_state(struct reg_flow * f); -void irm_flow_set_state(struct irm_flow * f, +void reg_flow_set_state(struct reg_flow * f, enum flow_state state); -int irm_flow_wait_state(struct irm_flow * f, +int reg_flow_wait_state(struct reg_flow * f, enum flow_state state, struct timespec * timeo); -#endif /* OUROBOROS_IRMD_IRM_FLOW_H */ +#endif /* OUROBOROS_IRMD_REG_FLOW_H */ diff --git a/src/irmd/reg/ipcp.c b/src/irmd/reg/ipcp.c new file mode 100644 index 00000000..62505871 --- /dev/null +++ b/src/irmd/reg/ipcp.c @@ -0,0 +1,152 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - IPCPs + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#if defined(__linux__) || defined(__CYGWIN__) +#define _DEFAULT_SOURCE +#else +#define _POSIX_C_SOURCE 200809L +#endif + +#include "config.h" + +#include <ouroboros/errno.h> +#include <ouroboros/hash.h> +#include <ouroboros/ipcp.h> +#include <ouroboros/pthread.h> +#include <ouroboros/time_utils.h> + +#include "ipcp.h" + +#include <assert.h> +#include <signal.h> +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> + +struct reg_ipcp * reg_ipcp_create(const char * name, + enum ipcp_type type) +{ + struct reg_ipcp * ipcp; + pthread_condattr_t cattr; + + ipcp = malloc(sizeof(*ipcp)); + if (ipcp == NULL) + goto fail_malloc; + + if (pthread_mutex_init(&ipcp->mtx, NULL)) + goto fail_mutex; + + if (pthread_condattr_init(&cattr)) + goto fail_cattr; +#ifndef __APPLE__ + pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); +#endif + if (pthread_cond_init(&ipcp->cond, &cattr)) + goto fail_cond; + + ipcp->name = strdup(name); + if (ipcp->name == NULL) + goto fail_name; + + pthread_condattr_destroy(&cattr); + + ipcp->layer = NULL; + ipcp->type = type; + ipcp->state = IPCP_BOOT; + + list_head_init(&ipcp->next); + + return ipcp; + + fail_name: + pthread_cond_destroy(&ipcp->cond); + fail_cond: + pthread_condattr_destroy(&cattr); + fail_cattr: + pthread_mutex_destroy(&ipcp->mtx); + fail_mutex: + free(ipcp); + fail_malloc: + return NULL; +} + +void reg_ipcp_destroy(struct reg_ipcp * ipcp) +{ + assert(ipcp); + + pthread_mutex_lock(&ipcp->mtx); + + while (ipcp->state == IPCP_BOOT) + pthread_cond_wait(&ipcp->cond, &ipcp->mtx); + + free(ipcp->layer); + free(ipcp->name); + + pthread_mutex_unlock(&ipcp->mtx); + + pthread_cond_destroy(&ipcp->cond); + pthread_mutex_destroy(&ipcp->mtx); + + free(ipcp); +} + +void reg_ipcp_set_state(struct reg_ipcp * ipcp, + enum ipcp_state state) +{ + pthread_mutex_lock(&ipcp->mtx); + + ipcp->state = state; + pthread_cond_broadcast(&ipcp->cond); + + pthread_mutex_unlock(&ipcp->mtx); +} + +int reg_ipcp_wait_boot(struct reg_ipcp * ipcp) +{ + int ret = 0; + struct timespec dl; + struct timespec to = {SOCKET_TIMEOUT / 1000, + (SOCKET_TIMEOUT % 1000) * MILLION}; + + clock_gettime(PTHREAD_COND_CLOCK, &dl); + ts_add(&dl, &to, &dl); + + pthread_mutex_lock(&ipcp->mtx); + + while (ipcp->state == IPCP_BOOT && ret != ETIMEDOUT) + ret = pthread_cond_timedwait(&ipcp->cond, &ipcp->mtx, &dl); + + if (ret == ETIMEDOUT) { + kill(ipcp->pid, SIGTERM); + ipcp->state = IPCP_NULL; + pthread_cond_signal(&ipcp->cond); + } + + if (ipcp->state != IPCP_LIVE) { + pthread_mutex_unlock(&ipcp->mtx); + return -1; + } + + pthread_mutex_unlock(&ipcp->mtx); + + return 0; +} diff --git a/src/irmd/reg/ipcp.h b/src/irmd/reg/ipcp.h new file mode 100644 index 00000000..8ad334cf --- /dev/null +++ b/src/irmd/reg/ipcp.h @@ -0,0 +1,58 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - IPCPs + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#ifndef OUROBOROS_IRMD_REG_IPCP_H +#define OUROBOROS_IRMD_REG_IPCP_H + +#include <ouroboros/list.h> + +enum ipcp_state { + IPCP_NULL = 0, + IPCP_BOOT, + IPCP_LIVE +}; + +struct reg_ipcp { + struct list_head next; + + char * name; + pid_t pid; + enum ipcp_type type; + enum hash_algo dir_hash_algo; + char * layer; + + enum ipcp_state state; + pthread_cond_t cond; + pthread_mutex_t mtx; +}; + +struct reg_ipcp * reg_ipcp_create(const char * name, + enum ipcp_type type); + +void reg_ipcp_destroy(struct reg_ipcp * i); + +void reg_ipcp_set_state(struct reg_ipcp * i, + enum ipcp_state state); + +int reg_ipcp_wait_boot(struct reg_ipcp * i); + +#endif /* OUROBOROS_IRMD_REG_IPCP_H */
\ No newline at end of file diff --git a/src/irmd/reg/name.c b/src/irmd/reg/name.c new file mode 100644 index 00000000..7e13e888 --- /dev/null +++ b/src/irmd/reg/name.c @@ -0,0 +1,451 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - Names + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#if defined(__linux__) || defined(__CYGWIN__) +#define _DEFAULT_SOURCE +#else +#define _POSIX_C_SOURCE 200809L +#endif + +#include "config.h" + +#define OUROBOROS_PREFIX "reg_name" + +#include <ouroboros/errno.h> +#include <ouroboros/logs.h> +#include <ouroboros/time_utils.h> +#include <ouroboros/pthread.h> + +#include "name.h" +#include "utils.h" + +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <signal.h> +#include <unistd.h> +#include <limits.h> +#include <assert.h> + +struct reg_name * reg_name_create(const char * name, + enum pol_balance lb) +{ + pthread_condattr_t cattr; + struct reg_name * n; + + assert(name != NULL); + + n = malloc(sizeof(*n)); + if (n == NULL) + goto fail_malloc; + + if (pthread_condattr_init(&cattr)) + goto fail_cattr; + +#ifndef __APPLE__ + pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); +#endif + if (pthread_cond_init(&n->cond, &cattr)) + goto fail_cond; + + if (pthread_mutex_init(&n->mtx, NULL)) + goto fail_mutex; + + n->name = strdup(name); + if (n->name == NULL) + goto fail_name; + + pthread_condattr_destroy(&cattr); + + list_head_init(&n->next); + list_head_init(&n->reg_progs); + list_head_init(&n->reg_pids); + + n->pol_lb = lb; + n->state = NAME_IDLE; + + return n; + + fail_name: + pthread_mutex_destroy(&n->mtx); + fail_mutex: + pthread_cond_destroy(&n->cond); + fail_cond: + pthread_condattr_destroy(&cattr); + fail_cattr: + free(n); + fail_malloc: + return NULL; +} + +static void cancel_reg_name_destroy(void * o) +{ + struct reg_name * name; + struct list_head * p; + struct list_head * h; + + name = (struct reg_name *) o; + + pthread_mutex_unlock(&name->mtx); + + pthread_cond_destroy(&name->cond); + pthread_mutex_destroy(&name->mtx); + + if (name->name != NULL) + free(name->name); + + list_for_each_safe(p, h, &name->reg_pids) { + struct pid_el * pe = list_entry(p, struct pid_el, next); + list_del(&pe->next); + free(pe); + } + + list_for_each_safe(p, h, &name->reg_progs) { + struct str_el * se = list_entry(p, struct str_el, next); + list_del(&se->next); + free(se->str); + free(se); + } + + free(name); +} + +void reg_name_destroy(struct reg_name * name) +{ + if (name == NULL) + return; + + pthread_mutex_lock(&name->mtx); + + if (name->state == NAME_DESTROY) { + pthread_mutex_unlock(&name->mtx); + return; + } + + if (name->state != NAME_FLOW_ACCEPT) + name->state = NAME_NULL; + else + name->state = NAME_DESTROY; + + pthread_cond_broadcast(&name->cond); + + pthread_cleanup_push(cancel_reg_name_destroy, name); + + while (name->state != NAME_NULL) + pthread_cond_wait(&name->cond, &name->mtx); + + pthread_cleanup_pop(true); +} + +static bool reg_name_has_prog(struct reg_name * name, + const char * prog) +{ + struct list_head * p; + + list_for_each(p, &name->reg_progs) { + struct str_el * name = list_entry(p, struct str_el, next); + if (!strcmp(name->str, prog)) + return true; + } + + return false; +} + +int reg_name_add_prog(struct reg_name * name, + struct reg_prog * a) +{ + struct str_el * n; + + if (reg_name_has_prog(name, a->prog)) { + log_warn("Program %s already accepting flows for %s.", + a->prog, name->name); + return 0; + } + + if (!(a->flags & BIND_AUTO)) { + log_dbg("Program %s cannot be auto-instantiated.", a->prog); + return 0; + } + + n = malloc(sizeof(*n)); + if (n == NULL) + return -ENOMEM; + + n->str = strdup(a->prog); + if (n->str == NULL) { + free(n); + return -ENOMEM; + } + + list_add(&n->next, &name->reg_progs); + + pthread_mutex_lock(&name->mtx); + + if (name->state == NAME_IDLE) + name->state = NAME_AUTO_ACCEPT; + + pthread_mutex_unlock(&name->mtx); + + return 0; +} + +void reg_name_del_prog(struct reg_name * name, + const char * prog) +{ + struct list_head * p; + struct list_head * h; + + list_for_each_safe(p, h, &name->reg_progs) { + struct str_el * se = list_entry(p, struct str_el, next); + if (strcmp(prog, se->str) == 0) { + list_del(&se->next); + free(se->str); + free(se); + } + } + + pthread_mutex_lock(&name->mtx); + + if (name->state == NAME_AUTO_ACCEPT && list_is_empty(&name->reg_progs)) { + name->state = NAME_IDLE; + pthread_cond_broadcast(&name->cond); + } + + pthread_mutex_unlock(&name->mtx); +} + +char * reg_name_get_prog(struct reg_name * name) +{ + if (!list_is_empty(&name->reg_pids) || list_is_empty(&name->reg_progs)) + return NULL; + + return list_first_entry(&name->reg_progs, struct str_el, next)->str; +} + +static bool reg_name_has_pid(struct reg_name * name, + pid_t pid) +{ + struct list_head * p; + + list_for_each(p, &name->reg_progs) { + struct pid_el * name = list_entry(p, struct pid_el, next); + if (name->pid == pid) + return true; + } + + return false; +} + +int reg_name_add_pid(struct reg_name * name, + pid_t pid) +{ + struct pid_el * i; + + assert(name); + + if (reg_name_has_pid(name, pid)) { + log_dbg("Process already registered with this name."); + return -EPERM; + } + + pthread_mutex_lock(&name->mtx); + + if (name->state == NAME_NULL) { + pthread_mutex_unlock(&name->mtx); + log_dbg("Tried to add instance in NULL state."); + return -EPERM; + } + + i = malloc(sizeof(*i)); + if (i == NULL) { + pthread_mutex_unlock(&name->mtx); + return -ENOMEM; + } + + i->pid = pid; + + /* load balancing policy assigns queue order for this process. */ + switch(name->pol_lb) { + case LB_RR: /* Round robin policy. */ + list_add_tail(&i->next, &name->reg_pids); + break; + case LB_SPILL: /* Keep accepting flows on the current process */ + list_add(&i->next, &name->reg_pids); + break; + default: + free(i); + assert(false); + }; + + if (name->state == NAME_IDLE || + name->state == NAME_AUTO_ACCEPT || + name->state == NAME_AUTO_EXEC) { + name->state = NAME_FLOW_ACCEPT; + pthread_cond_broadcast(&name->cond); + } + + pthread_mutex_unlock(&name->mtx); + + return 0; +} + +void reg_name_set_policy(struct reg_name * name, + enum pol_balance lb) +{ + name->pol_lb = lb; +} + +static void reg_name_check_state(struct reg_name * name) +{ + assert(name); + + if (name->state == NAME_DESTROY) { + name->state = NAME_NULL; + pthread_cond_broadcast(&name->cond); + return; + } + + if (list_is_empty(&name->reg_pids)) { + if (!list_is_empty(&name->reg_progs)) + name->state = NAME_AUTO_ACCEPT; + else + name->state = NAME_IDLE; + } else { + name->state = NAME_FLOW_ACCEPT; + } + + pthread_cond_broadcast(&name->cond); +} + +void reg_name_del_pid_el(struct reg_name * name, + struct pid_el * p) +{ + assert(name); + assert(p); + + list_del(&p->next); + free(p); + + reg_name_check_state(name); +} + +void reg_name_del_pid(struct reg_name * name, + pid_t pid) +{ + struct list_head * p; + struct list_head * h; + + assert(name); + + if (name == NULL) + return; + + list_for_each_safe(p, h, &name->reg_pids) { + struct pid_el * a = list_entry(p, struct pid_el, next); + if (a->pid == pid) { + list_del(&a->next); + free(a); + } + } + + reg_name_check_state(name); +} + +pid_t reg_name_get_pid(struct reg_name * name) +{ + if (name == NULL) + return -1; + + if (list_is_empty(&name->reg_pids)) + return -1; + + return list_first_entry(&name->reg_pids, struct pid_el, next)->pid; +} + +enum name_state reg_name_get_state(struct reg_name * name) +{ + enum name_state state; + + assert(name); + + pthread_mutex_lock(&name->mtx); + + state = name->state; + + pthread_mutex_unlock(&name->mtx); + + return state; +} + +int reg_name_set_state(struct reg_name * name, + enum name_state state) +{ + assert(state != NAME_DESTROY); + + pthread_mutex_lock(&name->mtx); + + name->state = state; + pthread_cond_broadcast(&name->cond); + + pthread_mutex_unlock(&name->mtx); + + return 0; +} + +int reg_name_leave_state(struct reg_name * name, + enum name_state state, + struct timespec * timeout) +{ + struct timespec abstime; + int ret = 0; + + assert(name); + assert(state != NAME_DESTROY); + + if (timeout != NULL) { + clock_gettime(PTHREAD_COND_CLOCK, &abstime); + ts_add(&abstime, timeout, &abstime); + } + + pthread_mutex_lock(&name->mtx); + + pthread_cleanup_push(__cleanup_mutex_unlock, &name->mtx); + + while (name->state == state && ret != -ETIMEDOUT) + if (timeout) + ret = -pthread_cond_timedwait(&name->cond, + &name->mtx, + &abstime); + else + ret = -pthread_cond_wait(&name->cond, + &name->mtx); + + if (name->state == NAME_DESTROY) { + ret = -1; + name->state = NAME_NULL; + pthread_cond_broadcast(&name->cond); + } + + pthread_cleanup_pop(true); + + return ret; +} diff --git a/src/irmd/reg/name.h b/src/irmd/reg/name.h new file mode 100644 index 00000000..0731782c --- /dev/null +++ b/src/irmd/reg/name.h @@ -0,0 +1,103 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - Names + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#ifndef OUROBOROS_IRMD_REG_NAME_H +#define OUROBOROS_IRMD_REG_NAME_H + +#include <ouroboros/hash.h> +#include <ouroboros/ipcp.h> +#include <ouroboros/list.h> +#include <ouroboros/irm.h> + +#include "proc.h" +#include "prog.h" + +#include <stdint.h> +#include <stdbool.h> +#include <pthread.h> +#include <string.h> +#include <sys/types.h> + +enum name_state { + NAME_NULL = 0, + NAME_IDLE, + NAME_AUTO_ACCEPT, + NAME_AUTO_EXEC, + NAME_FLOW_ACCEPT, + NAME_FLOW_ARRIVED, + NAME_DESTROY +}; + +/* An entry in the registry */ +struct reg_name { + struct list_head next; + char * name; + + /* Policies for this name. */ + enum pol_balance pol_lb; /* Load balance incoming flows. */ + /* Programs that can be instantiated by the irmd. */ + struct list_head reg_progs; + /* Processes that are listening for this name. */ + struct list_head reg_pids; + + enum name_state state; + pthread_cond_t cond; + pthread_mutex_t mtx; +}; + +struct reg_name * reg_name_create(const char * name, + enum pol_balance lb); + +void reg_name_destroy(struct reg_name * n); + +int reg_name_add_prog(struct reg_name * n, + struct reg_prog * p); + +void reg_name_del_prog(struct reg_name * n, + const char * prog); + +char * reg_name_get_prog(struct reg_name * n); + +int reg_name_add_pid(struct reg_name * n, + pid_t pid); + +void reg_name_del_pid(struct reg_name * n, + pid_t pid); + +void reg_name_del_pid_el(struct reg_name * n, + struct pid_el * p); + +pid_t reg_name_get_pid(struct reg_name * n); + +void reg_name_set_policy(struct reg_name * n, + enum pol_balance lb); + +enum name_state reg_name_get_state(struct reg_name * n); + +int reg_name_set_state(struct reg_name * n, + enum name_state state); + +int reg_name_leave_state(struct reg_name * n, + enum name_state state, + struct timespec * timeout); + +#endif /* OUROBOROS_IRMD_REG_NAME_H */ diff --git a/src/irmd/reg/proc.c b/src/irmd/reg/proc.c new file mode 100644 index 00000000..1aae789d --- /dev/null +++ b/src/irmd/reg/proc.c @@ -0,0 +1,265 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - Processes + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#if defined(__linux__) || defined(__CYGWIN__) +#define _DEFAULT_SOURCE +#else +#define _POSIX_C_SOURCE 200112L +#endif + +#include "config.h" + +#include <ouroboros/list.h> +#include <ouroboros/errno.h> +#include <ouroboros/time_utils.h> + +#include "proc.h" +#include "name.h" + +#include <stdlib.h> +#include <unistd.h> +#include <limits.h> +#include <assert.h> + +struct reg_proc * reg_proc_create(pid_t pid, + const char * prog) +{ + struct reg_proc * proc; + pthread_condattr_t cattr; + + assert(prog); + + proc = malloc(sizeof(*proc)); + if (proc == NULL) + goto fail_malloc; + + if (pthread_condattr_init(&cattr)) + goto fail_condattr; + +#ifndef __APPLE__ + pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); +#endif + + if (pthread_mutex_init(&proc->lock, NULL)) + goto fail_mutex; + + if (pthread_cond_init(&proc->cond, &cattr)) + goto fail_cond; + + proc->set = shm_flow_set_create(pid); + if (proc->set == NULL) + goto fail_set; + + proc->prog = strdup(prog); + if(proc->prog == NULL) + goto fail_prog; + + list_head_init(&proc->next); + list_head_init(&proc->names); + + proc->pid = pid; + proc->name = NULL; + proc->state = PROC_INIT; + + return proc; + + fail_prog: + shm_flow_set_destroy(proc->set); + fail_set: + pthread_cond_destroy(&proc->cond);; + fail_cond: + pthread_mutex_destroy(&proc->lock); + fail_mutex: + pthread_condattr_destroy(&cattr); + fail_condattr: + free(proc); + fail_malloc: + return NULL; +} + +static void cancel_reg_proc(void * o) +{ + struct reg_proc * proc = (struct reg_proc *) o; + + proc->state = PROC_NULL; + + pthread_mutex_unlock(&proc->lock); +} + +void reg_proc_destroy(struct reg_proc * proc) +{ + struct list_head * p; + struct list_head * h; + + assert(proc); + + pthread_mutex_lock(&proc->lock); + + if (proc->state == PROC_DESTROY) { + pthread_mutex_unlock(&proc->lock); + return; + } + + if (proc->state == PROC_SLEEP) + proc->state = PROC_DESTROY; + + pthread_cond_signal(&proc->cond); + + pthread_cleanup_push(cancel_reg_proc, proc); + + while (proc->state != PROC_INIT) + pthread_cond_wait(&proc->cond, &proc->lock); + + pthread_cleanup_pop(false); + + pthread_mutex_unlock(&proc->lock); + + shm_flow_set_destroy(proc->set); + + pthread_cond_destroy(&proc->cond); + pthread_mutex_destroy(&proc->lock); + + list_for_each_safe(p, h, &proc->names) { + struct str_el * n = list_entry(p, struct str_el, next); + list_del(&n->next); + if (n->str != NULL) + free(n->str); + free(n); + } + + free(proc->prog); + free(proc); +} + +int reg_proc_add_name(struct reg_proc * proc, + const char * name) +{ + struct str_el * s; + + assert(proc); + assert(name); + + s = malloc(sizeof(*s)); + if (s == NULL) + goto fail_malloc; + + s->str = strdup(name); + if (s->str == NULL) + goto fail_name; + + list_add(&s->next, &proc->names); + + return 0; + + fail_name: + free(s); + fail_malloc: + return -ENOMEM; +} + +void reg_proc_del_name(struct reg_proc * proc, + const char * name) +{ + struct list_head * p = NULL; + struct list_head * h = NULL; + + assert(proc); + assert(name); + + list_for_each_safe(p, h, &proc->names) { + struct str_el * s = list_entry(p, struct str_el, next); + if (!strcmp(name, s->str)) { + list_del(&s->next); + free(s->str); + free(s); + } + } +} + +int reg_proc_sleep(struct reg_proc * proc, + struct timespec * dl) +{ + + int ret = 0; + + assert(proc); + + pthread_mutex_lock(&proc->lock); + + if (proc->state != PROC_WAKE && proc->state != PROC_DESTROY) + proc->state = PROC_SLEEP; + + pthread_cleanup_push(cancel_reg_proc, proc); + + while (proc->state == PROC_SLEEP && ret != -ETIMEDOUT) + if (dl != NULL) + ret = -pthread_cond_timedwait(&proc->cond, + &proc->lock, dl); + else + ret = -pthread_cond_wait(&proc->cond, &proc->lock); + + pthread_cleanup_pop(false); + + if (proc->state == PROC_DESTROY) { + if (proc->name != NULL) + reg_name_del_pid(proc->name, proc->pid); + ret = -1; + } + + proc->state = PROC_INIT; + + pthread_cond_broadcast(&proc->cond); + pthread_mutex_unlock(&proc->lock); + + return ret; +} + +void reg_proc_wake(struct reg_proc * proc, + struct reg_name * name) +{ + assert(proc); + assert(name); + + pthread_mutex_lock(&proc->lock); + + if (proc->state != PROC_SLEEP) { + pthread_mutex_unlock(&proc->lock); + return; + } + + proc->state = PROC_WAKE; + proc->name = name; + + pthread_cond_broadcast(&proc->cond); + + pthread_cleanup_push(cancel_reg_proc, proc); + + while (proc->state == PROC_WAKE) + pthread_cond_wait(&proc->cond, &proc->lock); + + pthread_cleanup_pop(false); + + if (proc->state == PROC_DESTROY) + proc->state = PROC_INIT; + + pthread_mutex_unlock(&proc->lock); +} diff --git a/src/irmd/proc_table.h b/src/irmd/reg/proc.h index 68ddd1bb..fb11f34f 100644 --- a/src/irmd/proc_table.h +++ b/src/irmd/reg/proc.h @@ -1,7 +1,7 @@ /* * Ouroboros - Copyright (C) 2016 - 2023 * - * The IPC Resource Manager - Process Table + * The IPC Resource Manager - Registry - Processes * * Dimitri Staessens <dimitri@ouroboros.rocks> * Sander Vrijders <sander@ouroboros.rocks> @@ -20,8 +20,8 @@ * Foundation, Inc., http://www.fsf.org/about/contact/. */ -#ifndef OUROBOROS_IRMD_PROC_TABLE_H -#define OUROBOROS_IRMD_PROC_TABLE_H +#ifndef OUROBOROS_IRMD_REG_PROC_H +#define OUROBOROS_IRMD_REG_PROC_H #include <ouroboros/shm_flow_set.h> @@ -38,14 +38,14 @@ enum proc_state { PROC_DESTROY }; -struct proc_entry { +struct reg_proc { struct list_head next; pid_t pid; char * prog; /* program instantiated */ struct list_head names; /* names for which process accepts flows */ struct shm_flow_set * set; - struct reg_entry * re; /* reg_entry for which a flow arrived */ + struct reg_name * name; /* name for which a flow arrived */ /* The process will block on this */ enum proc_state state; @@ -53,32 +53,23 @@ struct proc_entry { pthread_mutex_t lock; }; -struct proc_entry * proc_entry_create(pid_t proc, - char * prog); +struct reg_proc * reg_proc_create(pid_t proc, + const char * prog); -void proc_entry_destroy(struct proc_entry * e); +void reg_proc_destroy(struct reg_proc * proc); -int proc_entry_sleep(struct proc_entry * e, - struct timespec * timeo); +int reg_proc_sleep(struct reg_proc * proc, + struct timespec * timeo); -void proc_entry_wake(struct proc_entry * e, - struct reg_entry * re); +void reg_proc_wake(struct reg_proc * proc, + struct reg_name * name); -void proc_entry_cancel(struct proc_entry * e); +void reg_proc_cancel(struct reg_proc * proc); -int proc_entry_add_name(struct proc_entry * e, - char * name); +int reg_proc_add_name(struct reg_proc * proc, + const char * name); -void proc_entry_del_name(struct proc_entry * e, - const char * name); +void reg_proc_del_name(struct reg_proc * proc, + const char * name); -int proc_table_add(struct list_head * proc_table, - struct proc_entry * e); - -void proc_table_del(struct list_head * proc_table, - pid_t pid); - -struct proc_entry * proc_table_get(struct list_head * proc_table, - pid_t pid); - -#endif /* OUROBOROS_IRMD_PROC_TABLE_H */ +#endif /* OUROBOROS_IRMD_REG_PROC_H */ diff --git a/src/irmd/reg/prog.c b/src/irmd/reg/prog.c new file mode 100644 index 00000000..e3fd6105 --- /dev/null +++ b/src/irmd/reg/prog.c @@ -0,0 +1,174 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2023 + * + * The IPC Resource Manager - Registry - Programs + * + * Dimitri Staessens <dimitri@ouroboros.rocks> + * Sander Vrijders <sander@ouroboros.rocks> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#if defined(__linux__) || defined(__CYGWIN__) +#define _DEFAULT_SOURCE +#else +#define _POSIX_C_SOURCE 200809L +#endif + +#include <ouroboros/errno.h> +#include <ouroboros/irm.h> +#include <ouroboros/utils.h> + +#include "prog.h" +#include "utils.h" + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + + +static char ** create_argv(const char * prog, + size_t argc, + char ** argv) +{ + char ** argv2; + size_t i; + + argv2 = malloc((argc + 2) * sizeof(*argv2)); /* prog + args + NULL */ + if (argv2 == 0) + goto fail_malloc; + + argv2[0] = strdup(prog); + if (argv2[0] == NULL) + goto fail_prog; + + for (i = 1; i <= argc; ++i) { + argv2[i] = strdup(argv[i - 1]); + if (argv2[i] == NULL) + goto fail_arg; + } + + argv2[argc + 1] = NULL; + + return argv2; + + fail_arg: + argvfree(argv2); + fail_prog: + free(argv2); + fail_malloc: + return NULL; +} + +struct reg_prog * reg_prog_create(const char * prog, + uint32_t flags, + int argc, + char ** argv) +{ + struct reg_prog * p; + + assert(prog); + + p = malloc(sizeof(*p)); + if (p == NULL) + goto fail_malloc; + + memset(p, 0, sizeof(*p)); + + p->prog = strdup(path_strip(prog)); + if (p->prog == NULL) + goto fail_prog; + + if (argc > 0 && flags & BIND_AUTO) { + p->argv = create_argv(prog, argc, argv); + if (p->argv == NULL) + goto fail_argv; + } + + list_head_init(&p->next); + list_head_init(&p->names); + + p->flags = flags; + + return p; + + fail_argv: + free(p->prog); + fail_prog: + free(p); + fail_malloc: + return NULL; +} + +void reg_prog_destroy(struct reg_prog * prog) +{ + struct list_head * p; + struct list_head * h; + + if (prog == NULL) + return; + + list_for_each_safe(p, h, &prog->names) { + struct str_el * s = list_entry(p, struct str_el, next); + list_del(&s->next); + free(s->str); + free(s); + } + + argvfree(prog->argv); + free(prog->prog); + free(prog); +} + +int reg_prog_add_name(struct reg_prog * prog, + const char * name) +{ + struct str_el * s; + + if (prog == NULL || name == NULL) + return -EINVAL; + + s = malloc(sizeof(*s)); + if (s == NULL) + goto fail_malloc; + + s->str = strdup(name); + if(s->str == NULL) + goto fail_name; + + list_add(&s->next, &prog->names); + + return 0; + + fail_name: + free(s); + fail_malloc: + return -ENOMEM; +} + +void reg_prog_del_name(struct reg_prog * prog, + const char * name) +{ + struct list_head * p; + struct list_head * h; + + list_for_each_safe(p, h, &prog->names) { + struct str_el * s = list_entry(p, struct str_el, next); + if (!strcmp(name, s->str)) { + list_del(&s->next); + free(s->str); + free(s); + } + } +} diff --git a/src/irmd/prog_table.h b/src/irmd/reg/prog.h index 6db29365..c45f2d8c 100644 --- a/src/irmd/prog_table.h +++ b/src/irmd/reg/prog.h @@ -1,7 +1,7 @@ /* * Ouroboros - Copyright (C) 2016 - 2023 * - * The IPC Resource Manager - Program Table + * The IPC Resource Manager - Registry - Programs * * Dimitri Staessens <dimitri@ouroboros.rocks> * Sander Vrijders <sander@ouroboros.rocks> @@ -20,15 +20,15 @@ * Foundation, Inc., http://www.fsf.org/about/contact/. */ -#ifndef OUROBOROS_IRMD_PROG_TABLE_H -#define OUROBOROS_IRMD_PROG_TABLE_H +#ifndef OUROBOROS_IRMD_REG_PROG_H +#define OUROBOROS_IRMD_REG_PROG_H #include <ouroboros/list.h> #include <unistd.h> #include <stdint.h> -struct prog_entry { +struct reg_prog { struct list_head next; char * prog; /* name of binary */ uint32_t flags; @@ -36,25 +36,17 @@ struct prog_entry { struct list_head names; /* names that all instances will listen for */ }; -struct prog_entry * prog_entry_create(char * prog, - uint32_t flags, - char ** argv); +struct reg_prog * reg_prog_create(const char * prog, + uint32_t flags, + int argc, + char ** argv); -void prog_entry_destroy(struct prog_entry * e); +void reg_prog_destroy(struct reg_prog * prog); -int prog_entry_add_name(struct prog_entry * e, - char * name); +int reg_prog_add_name(struct reg_prog * prog, + const char * name); -void prog_entry_del_name(struct prog_entry * e, - char * name); +void reg_prog_del_name(struct reg_prog * prog, + const char * name); -int prog_table_add(struct list_head * prog_table, - struct prog_entry * e); - -void prog_table_del(struct list_head * prog_table, - char * prog); - -struct prog_entry * prog_table_get(struct list_head * prog_table, - char * prog); - -#endif /* OUROBOROS_IRMD_PROG_TABLE_H */ +#endif /* OUROBOROS_IRMD_REG_PROG_H */ diff --git a/src/irmd/registry.c b/src/irmd/registry.c deleted file mode 100644 index b34e9494..00000000 --- a/src/irmd/registry.c +++ /dev/null @@ -1,577 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2023 - * - * The IPC Resource Manager - Registry - * - * Dimitri Staessens <dimitri@ouroboros.rocks> - * Sander Vrijders <sander@ouroboros.rocks> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., http://www.fsf.org/about/contact/. - */ - -#if defined(__linux__) || defined(__CYGWIN__) -#define _DEFAULT_SOURCE -#else -#define _POSIX_C_SOURCE 200809L -#endif - -#include "config.h" - -#define OUROBOROS_PREFIX "registry" - -#include <ouroboros/errno.h> -#include <ouroboros/logs.h> -#include <ouroboros/time_utils.h> -#include <ouroboros/pthread.h> - -#include "registry.h" -#include "utils.h" - -#include <stdlib.h> -#include <stdbool.h> -#include <string.h> -#include <signal.h> -#include <unistd.h> -#include <limits.h> -#include <assert.h> - -static struct reg_entry * reg_entry_create(void) -{ - struct reg_entry * e; - - e = malloc(sizeof(*e)); - if (e == NULL) - return NULL; - - e->name = NULL; - e->state = REG_NAME_NULL; - - return e; -} - -static int reg_entry_init(struct reg_entry * e, - char * name) -{ - pthread_condattr_t cattr; - - assert(e); - assert(name); - - list_head_init(&e->next); - list_head_init(&e->reg_progs); - list_head_init(&e->reg_pids); - - e->name = name; - e->pol_lb = 0; - - if (pthread_condattr_init(&cattr)) - goto fail_cattr; - -#ifndef __APPLE__ - pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK); -#endif - if (pthread_cond_init(&e->state_cond, &cattr)) - goto fail_cond; - - if (pthread_mutex_init(&e->state_lock, NULL)) - goto fail_mutex; - - pthread_condattr_destroy(&cattr); - - e->state = REG_NAME_IDLE; - - return 0; - - fail_mutex: - pthread_cond_destroy(&e->state_cond); - fail_cond: - pthread_condattr_destroy(&cattr); - fail_cattr: - return -1; -} - -static void cancel_reg_entry_destroy(void * o) -{ - struct reg_entry * e; - struct list_head * p; - struct list_head * h; - - e = (struct reg_entry *) o; - - pthread_mutex_unlock(&e->state_lock); - - pthread_cond_destroy(&e->state_cond); - pthread_mutex_destroy(&e->state_lock); - - if (e->name != NULL) - free(e->name); - - list_for_each_safe(p, h, &e->reg_pids) { - struct pid_el * pe = list_entry(p, struct pid_el, next); - list_del(&pe->next); - free(pe); - } - - list_for_each_safe(p, h, &e->reg_progs) { - struct str_el * a = list_entry(p, struct str_el, next); - list_del(&a->next); - free(a->str); - free(a); - } - - free(e); -} - -static void reg_entry_destroy(struct reg_entry * e) -{ - if (e == NULL) - return; - - pthread_mutex_lock(&e->state_lock); - - if (e->state == REG_NAME_DESTROY) { - pthread_mutex_unlock(&e->state_lock); - return; - } - - if (e->state != REG_NAME_FLOW_ACCEPT) - e->state = REG_NAME_NULL; - else - e->state = REG_NAME_DESTROY; - - pthread_cond_broadcast(&e->state_cond); - - pthread_cleanup_push(cancel_reg_entry_destroy, e); - - while (e->state != REG_NAME_NULL) - pthread_cond_wait(&e->state_cond, &e->state_lock); - - pthread_cleanup_pop(true); -} - -static bool reg_entry_has_prog(struct reg_entry * e, - const char * prog) -{ - struct list_head * p; - - list_for_each(p, &e->reg_progs) { - struct str_el * e = list_entry(p, struct str_el, next); - if (!strcmp(e->str, prog)) - return true; - } - - return false; -} - -int reg_entry_add_prog(struct reg_entry * e, - struct prog_entry * a) -{ - struct str_el * n; - - if (reg_entry_has_prog(e, a->prog)) { - log_warn("Program %s already accepting flows for %s.", - a->prog, e->name); - return 0; - } - - if (!(a->flags & BIND_AUTO)) { - log_dbg("Program %s cannot be auto-instantiated.", a->prog); - return 0; - } - - n = malloc(sizeof(*n)); - if (n == NULL) - return -ENOMEM; - - n->str = strdup(a->prog); - if (n->str == NULL) { - free(n); - return -ENOMEM; - } - - list_add(&n->next, &e->reg_progs); - - pthread_mutex_lock(&e->state_lock); - - if (e->state == REG_NAME_IDLE) - e->state = REG_NAME_AUTO_ACCEPT; - - pthread_mutex_unlock(&e->state_lock); - - return 0; -} - -void reg_entry_del_prog(struct reg_entry * e, - const char * prog) -{ - struct list_head * p; - struct list_head * h; - - list_for_each_safe(p, h, &e->reg_progs) { - struct str_el * e = list_entry(p, struct str_el, next); - if (!strcmp(prog, e->str)) { - list_del(&e->next); - free(e->str); - free(e); - } - } - - pthread_mutex_lock(&e->state_lock); - - if (e->state == REG_NAME_AUTO_ACCEPT && list_is_empty(&e->reg_progs)) { - e->state = REG_NAME_IDLE; - pthread_cond_broadcast(&e->state_cond); - } - - pthread_mutex_unlock(&e->state_lock); -} - -char * reg_entry_get_prog(struct reg_entry * e) -{ - if (!list_is_empty(&e->reg_pids) || list_is_empty(&e->reg_progs)) - return NULL; - - return list_first_entry(&e->reg_progs, struct str_el, next)->str; -} - -static bool reg_entry_has_pid(struct reg_entry * e, - pid_t pid) -{ - struct list_head * p; - - list_for_each(p, &e->reg_progs) { - struct pid_el * e = list_entry(p, struct pid_el, next); - if (e->pid == pid) - return true; - } - - return false; -} - -int reg_entry_add_pid(struct reg_entry * e, - pid_t pid) -{ - struct pid_el * i; - - assert(e); - - if (reg_entry_has_pid(e, pid)) { - log_dbg("Process already registered with this name."); - return -EPERM; - } - - pthread_mutex_lock(&e->state_lock); - - if (e->state == REG_NAME_NULL) { - pthread_mutex_unlock(&e->state_lock); - log_dbg("Tried to add instance in NULL state."); - return -EPERM; - } - - i = malloc(sizeof(*i)); - if (i == NULL) { - pthread_mutex_unlock(&e->state_lock); - return -ENOMEM; - } - - i->pid = pid; - - /* load balancing policy assigns queue order for this process. */ - switch(e->pol_lb) { - case LB_RR: /* Round robin policy. */ - list_add_tail(&i->next, &e->reg_pids); - break; - case LB_SPILL: /* Keep accepting flows on the current process */ - list_add(&i->next, &e->reg_pids); - break; - default: - free(i); - assert(false); - }; - - if (e->state == REG_NAME_IDLE || - e->state == REG_NAME_AUTO_ACCEPT || - e->state == REG_NAME_AUTO_EXEC) { - e->state = REG_NAME_FLOW_ACCEPT; - pthread_cond_broadcast(&e->state_cond); - } - - pthread_mutex_unlock(&e->state_lock); - - return 0; -} - -void reg_entry_set_policy(struct reg_entry * e, - enum pol_balance p) -{ - e->pol_lb = p; -} - - -static void reg_entry_check_state(struct reg_entry * e) -{ - assert(e); - - if (e->state == REG_NAME_DESTROY) { - e->state = REG_NAME_NULL; - pthread_cond_broadcast(&e->state_cond); - return; - } - - if (list_is_empty(&e->reg_pids)) { - if (!list_is_empty(&e->reg_progs)) - e->state = REG_NAME_AUTO_ACCEPT; - else - e->state = REG_NAME_IDLE; - } else { - e->state = REG_NAME_FLOW_ACCEPT; - } - - pthread_cond_broadcast(&e->state_cond); -} - -void reg_entry_del_pid_el(struct reg_entry * e, - struct pid_el * p) -{ - assert(e); - assert(p); - - list_del(&p->next); - free(p); - - reg_entry_check_state(e); -} - -void reg_entry_del_pid(struct reg_entry * e, - pid_t pid) -{ - struct list_head * p; - struct list_head * h; - - assert(e); - - if (e == NULL) - return; - - list_for_each_safe(p, h, &e->reg_pids) { - struct pid_el * a = list_entry(p, struct pid_el, next); - if (a->pid == pid) { - list_del(&a->next); - free(a); - } - } - - reg_entry_check_state(e); -} - -pid_t reg_entry_get_pid(struct reg_entry * e) -{ - if (e == NULL) - return -1; - - if (list_is_empty(&e->reg_pids)) - return -1; - - return list_first_entry(&e->reg_pids, struct pid_el, next)->pid; -} - -enum reg_name_state reg_entry_get_state(struct reg_entry * e) -{ - enum reg_name_state state; - - assert(e); - - pthread_mutex_lock(&e->state_lock); - - state = e->state; - - pthread_mutex_unlock(&e->state_lock); - - return state; -} - -int reg_entry_set_state(struct reg_entry * e, - enum reg_name_state state) -{ - assert(state != REG_NAME_DESTROY); - - pthread_mutex_lock(&e->state_lock); - - e->state = state; - pthread_cond_broadcast(&e->state_cond); - - pthread_mutex_unlock(&e->state_lock); - - return 0; -} - -int reg_entry_leave_state(struct reg_entry * e, - enum reg_name_state state, - struct timespec * timeout) -{ - struct timespec abstime; - int ret = 0; - - assert(e); - assert(state != REG_NAME_DESTROY); - - if (timeout != NULL) { - clock_gettime(PTHREAD_COND_CLOCK, &abstime); - ts_add(&abstime, timeout, &abstime); - } - - pthread_mutex_lock(&e->state_lock); - - pthread_cleanup_push(__cleanup_mutex_unlock, &e->state_lock); - - while (e->state == state && ret != -ETIMEDOUT) - if (timeout) - ret = -pthread_cond_timedwait(&e->state_cond, - &e->state_lock, - &abstime); - else - ret = -pthread_cond_wait(&e->state_cond, - &e->state_lock); - - if (e->state == REG_NAME_DESTROY) { - ret = -1; - e->state = REG_NAME_NULL; - pthread_cond_broadcast(&e->state_cond); - } - - pthread_cleanup_pop(true); - - return ret; -} - -struct reg_entry * registry_get_entry(struct list_head * registry, - const char * name) -{ - struct list_head * p = NULL; - - assert(registry); - - list_for_each(p, registry) { - struct reg_entry * e = list_entry(p, struct reg_entry, next); - if (!strcmp(name, e->name)) - return e; - } - - return NULL; -} - -struct reg_entry * registry_get_entry_by_hash(struct list_head * registry, - enum hash_algo algo, - const uint8_t * hash, - size_t len) -{ - struct list_head * p = NULL; - uint8_t * thash; - - thash = malloc(len); - if (thash == NULL) - return NULL; - - assert(registry); - - list_for_each(p, registry) { - struct reg_entry * e = list_entry(p, struct reg_entry, next); - str_hash(algo, thash, e->name); - if (memcmp(thash, hash, len) == 0) { - free(thash); - return e; - } - } - - free(thash); - - return NULL; -} - -struct reg_entry * registry_add_name(struct list_head * registry, - const char * name) -{ - struct reg_entry * e = NULL; - - assert(registry); - assert(name); - - if (registry_has_name(registry, name)) { - log_dbg("Name %s already registered.", name); - return NULL; - } - - e = reg_entry_create(); - if (e == NULL) { - log_dbg("Could not create registry entry."); - return NULL; - } - - if (reg_entry_init(e, strdup(name))) { - reg_entry_destroy(e); - log_dbg("Could not initialize registry entry."); - return NULL; - } - - list_add(&e->next, registry); - - return e; -} - -void registry_del_name(struct list_head * registry, - const char * name) -{ - struct reg_entry * e = registry_get_entry(registry, name); - if (e == NULL) - return; - - list_del(&e->next); - reg_entry_destroy(e); - - return; -} - -void registry_del_process(struct list_head * registry, - pid_t pid) -{ - struct list_head * p; - - assert(registry); - assert(pid > 0); - - list_for_each(p, registry) { - struct reg_entry * e = list_entry(p, struct reg_entry, next); - pthread_mutex_lock(&e->state_lock); - assert(e); - reg_entry_del_pid(e, pid); - pthread_mutex_unlock(&e->state_lock); - } - - return; -} - -void registry_destroy(struct list_head * registry) -{ - struct list_head * p = NULL; - struct list_head * h = NULL; - - assert(registry); - - list_for_each_safe(p, h, registry) { - struct reg_entry * e = list_entry(p, struct reg_entry, next); - list_del(&e->next); - reg_entry_set_state(e, REG_NAME_NULL); - reg_entry_destroy(e); - } -} diff --git a/src/irmd/registry.h b/src/irmd/registry.h deleted file mode 100644 index 6ad0890a..00000000 --- a/src/irmd/registry.h +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2023 - * - * The IPC Resource Manager - Registry - * - * Dimitri Staessens <dimitri@ouroboros.rocks> - * Sander Vrijders <sander@ouroboros.rocks> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., http://www.fsf.org/about/contact/. - */ - -#ifndef OUROBOROS_IRMD_REGISTRY_H -#define OUROBOROS_IRMD_REGISTRY_H - -#include <ouroboros/hash.h> -#include <ouroboros/ipcp.h> -#include <ouroboros/list.h> -#include <ouroboros/irm.h> - -#include "proc_table.h" -#include "prog_table.h" - -#include <stdint.h> -#include <stdbool.h> -#include <pthread.h> -#include <string.h> -#include <sys/types.h> - -#define registry_has_name(r, name) \ - (registry_get_entry(r, name) != NULL) - -enum reg_name_state { - REG_NAME_NULL = 0, - REG_NAME_IDLE, - REG_NAME_AUTO_ACCEPT, - REG_NAME_AUTO_EXEC, - REG_NAME_FLOW_ACCEPT, - REG_NAME_FLOW_ARRIVED, - REG_NAME_DESTROY -}; - -/* An entry in the registry */ -struct reg_entry { - struct list_head next; - char * name; - - /* Policies for this name. */ - enum pol_balance pol_lb; /* Load balance incoming flows. */ - /* Programs that can be instantiated by the irmd. */ - struct list_head reg_progs; - /* Processes that are listening for this name. */ - struct list_head reg_pids; - - enum reg_name_state state; - pthread_cond_t state_cond; - pthread_mutex_t state_lock; -}; - -int reg_entry_add_prog(struct reg_entry * e, - struct prog_entry * a); - -void reg_entry_del_prog(struct reg_entry * e, - const char * prog); - -char * reg_entry_get_prog(struct reg_entry * e); - -int reg_entry_add_pid(struct reg_entry * e, - pid_t pid); - -void reg_entry_del_pid(struct reg_entry * e, - pid_t pid); - -void reg_entry_del_pid_el(struct reg_entry * e, - struct pid_el * a); - -pid_t reg_entry_get_pid(struct reg_entry * e); - -void reg_entry_set_policy(struct reg_entry * e, - enum pol_balance p); - -enum reg_name_state reg_entry_get_state(struct reg_entry * e); - -int reg_entry_set_state(struct reg_entry * e, - enum reg_name_state state); - -int reg_entry_leave_state(struct reg_entry * e, - enum reg_name_state state, - struct timespec * timeout); - -struct reg_entry * registry_add_name(struct list_head * registry, - const char * name); - -void registry_del_name(struct list_head * registry, - const char * name); - -void registry_del_process(struct list_head * registry, - pid_t pid); - -void registry_sanitize_pids(struct list_head * registry); - -struct reg_entry * registry_get_entry(struct list_head * registry, - const char * name); - -struct reg_entry * registry_get_entry_by_hash(struct list_head * registry, - enum hash_algo algo, - const uint8_t * hash, - size_t len); - -void registry_destroy(struct list_head * registry); - -#endif /* OUROBOROS_IRMD_REGISTRY_H */ diff --git a/src/irmd/utils.c b/src/irmd/utils.c index 0e2a26e1..bae2b8b1 100644 --- a/src/irmd/utils.c +++ b/src/irmd/utils.c @@ -25,12 +25,27 @@ #include <stdlib.h> #include <string.h> +size_t argvlen(char ** argv) +{ + size_t argc = 0; + + if (argv == NULL) + return 0; + + while (*argv++ != NULL) + argc++; + + return argc; +} + void argvfree(char ** argv) { - char ** argv_dup = argv; + char ** argv_dup; + if (argv == NULL) return; + argv_dup = argv; while (*argv_dup != NULL) free(*(argv_dup++)); diff --git a/src/irmd/utils.h b/src/irmd/utils.h index 83585f21..45e59fd4 100644 --- a/src/irmd/utils.h +++ b/src/irmd/utils.h @@ -38,6 +38,8 @@ struct pid_el { }; /* functions for copying and destroying arguments list */ +size_t argvlen(char ** argv); + char ** argvdup(char ** argv); void argvfree(char ** argv); diff --git a/src/lib/utils.c b/src/lib/utils.c index e1ad11b9..df7a9150 100644 --- a/src/lib/utils.c +++ b/src/lib/utils.c @@ -35,14 +35,14 @@ int n_digits(unsigned i) return n; } -char * path_strip(char * src) +char * path_strip(const char * src) { - char * dst = NULL; + char * dst; if (src == NULL) return NULL; - dst = src + strlen(src); + dst = (char *) src + strlen(src); while (dst > src && *dst != '/') --dst; |