From 30d479c28c831a0d4f1fdb54a9e346b0fc176be1 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 08:23:09 +0200 Subject: Adding upstream version 1.7.2. Signed-off-by: Daniel Baumann --- threadproc/beos/apr_proc_stub.c | 76 ++++++ threadproc/beos/proc.c | 454 ++++++++++++++++++++++++++++++++++++ threadproc/beos/thread.c | 237 +++++++++++++++++++ threadproc/beos/threadpriv.c | 180 ++++++++++++++ threadproc/beos/threadproc_common.c | 21 ++ 5 files changed, 968 insertions(+) create mode 100644 threadproc/beos/apr_proc_stub.c create mode 100644 threadproc/beos/proc.c create mode 100644 threadproc/beos/thread.c create mode 100644 threadproc/beos/threadpriv.c create mode 100644 threadproc/beos/threadproc_common.c (limited to 'threadproc/beos') diff --git a/threadproc/beos/apr_proc_stub.c b/threadproc/beos/apr_proc_stub.c new file mode 100644 index 0000000..011d793 --- /dev/null +++ b/threadproc/beos/apr_proc_stub.c @@ -0,0 +1,76 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +struct pipefd { + int in; + int out; + int err; +}; + +int main(int argc, char *argv[]) { +/* we expect the following... + * + * argv[0] = this stub + * argv[1] = directory to run in... + * argv[2] = progname to execute + * rest of arguments to be passed to program + */ + char *progname = argv[2]; + char *directory = argv[1]; + struct pipefd *pfd; + thread_id sender; + void *buffer; + char ** newargs; + int i = 0; + + newargs = (char**)malloc(sizeof(char*) * (argc - 1)); + + buffer = (void*)malloc(sizeof(struct pipefd)); + /* this will block until we get the data */ + receive_data(&sender, buffer, sizeof(struct pipefd)); + pfd = (struct pipefd*)buffer; + + if (pfd->in > STDERR_FILENO) { + if (dup2(pfd->in, STDIN_FILENO) != STDIN_FILENO) return (-1); + close (pfd->in); + } + if (pfd->out > STDERR_FILENO) { + if (dup2(pfd->out, STDOUT_FILENO) != STDOUT_FILENO) return (-1); + close (pfd->out); + } + if (pfd->err > STDERR_FILENO) { + if (dup2(pfd->err, STDERR_FILENO) != STDERR_FILENO) return (-1); + close (pfd->err); + } + + for (i=3;i<=argc;i++){ + newargs[i-3] = argv[i]; + } + + /* tell the caller we're OK to start */ + send_data(sender,1,NULL,0); + + if (directory != NULL) + chdir(directory); + execve (progname, newargs, environ); + + return (-1); +} diff --git a/threadproc/beos/proc.c b/threadproc/beos/proc.c new file mode 100644 index 0000000..e369808 --- /dev/null +++ b/threadproc/beos/proc.c @@ -0,0 +1,454 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "apr_arch_threadproc.h" +#include "apr_strings.h" + +/* Heavy on no'ops, here's what we want to pass if there is APR_NO_FILE + * requested for a specific child handle; + */ +static apr_file_t no_file = { NULL, -1, }; + +struct send_pipe { + int in; + int out; + int err; +}; + +APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new, apr_pool_t *pool) +{ + (*new) = (apr_procattr_t *)apr_palloc(pool, + sizeof(apr_procattr_t)); + + if ((*new) == NULL) { + return APR_ENOMEM; + } + (*new)->pool = pool; + (*new)->parent_in = NULL; + (*new)->child_in = NULL; + (*new)->parent_out = NULL; + (*new)->child_out = NULL; + (*new)->parent_err = NULL; + (*new)->child_err = NULL; + (*new)->currdir = NULL; + (*new)->cmdtype = APR_PROGRAM; + (*new)->detached = 0; + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, + apr_int32_t in, + apr_int32_t out, + apr_int32_t err) +{ + apr_status_t rv; + + if ((in != APR_NO_PIPE) && (in != APR_NO_FILE)) { + /* APR_CHILD_BLOCK maps to APR_WRITE_BLOCK, while + * APR_PARENT_BLOCK maps to APR_READ_BLOCK, so transpose + * the CHILD/PARENT blocking flags for the stdin pipe. + * stdout/stderr map to the correct mode by default. + */ + if (in == APR_CHILD_BLOCK) + in = APR_READ_BLOCK; + else if (in == APR_PARENT_BLOCK) + in = APR_WRITE_BLOCK; + + if ((rv = apr_file_pipe_create_ex(&attr->child_in, &attr->parent_in, + in, attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_in); + if (rv != APR_SUCCESS) + return rv; + } + else if (in == APR_NO_FILE) + attr->child_in = &no_file; + + if ((out != APR_NO_PIPE) && (out != APR_NO_FILE)) { + if ((rv = apr_file_pipe_create_ex(&attr->parent_out, &attr->child_out, + out, attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_out); + if (rv != APR_SUCCESS) + return rv; + } + else if (out == APR_NO_FILE) + attr->child_out = &no_file; + + if ((err != APR_NO_PIPE) && (err != APR_NO_FILE)) { + if ((rv = apr_file_pipe_create_ex(&attr->parent_err, &attr->child_err, + err, attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_err); + if (rv != APR_SUCCESS) + return rv; + } + else if (err == APR_NO_FILE) + attr->child_err = &no_file; + + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, + const char *dir) +{ + char * cwd; + if (dir[0] != '/') { + cwd = (char*)malloc(sizeof(char) * PATH_MAX); + getcwd(cwd, PATH_MAX); + attr->currdir = (char *)apr_pstrcat(attr->pool, cwd, "/", dir, NULL); + free(cwd); + } else { + attr->currdir = (char *)apr_pstrdup(attr->pool, dir); + } + if (attr->currdir) { + return APR_SUCCESS; + } + return APR_ENOMEM; +} + +APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr, + apr_cmdtype_e cmd) +{ + attr->cmdtype = cmd; + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) +{ + attr->detached = detach; + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *pool) +{ + int pid; + + if ((pid = fork()) < 0) { + return errno; + } + else if (pid == 0) { + /* This is really ugly... + * The semantics of BeOS's fork() are that areas (used for shared + * memory) get COW'd :-( The only way we can make shared memory + * work across fork() is therefore to find any areas that have + * been created and then clone them into our address space. + * Thankfully only COW'd areas have the lock variable set at + * anything but 0, so we can use that to find the areas we need to + * copy. Of course what makes it even worse is that the loop through + * the area's will go into an infinite loop, eating memory and then + * eventually segfault unless we know when we reach then end of the + * "original" areas and stop. Why? Well, we delete the area and then + * add another to the end of the list... + */ + area_info ai; + int32 cookie = 0; + area_id highest = 0; + + while (get_next_area_info(0, &cookie, &ai) == B_OK) + if (ai.area > highest) + highest = ai.area; + cookie = 0; + while (get_next_area_info(0, &cookie, &ai) == B_OK) { + if (ai.area > highest) + break; + if (ai.lock > 0) { + area_id original = find_area(ai.name); + delete_area(ai.area); + clone_area(ai.name, &ai.address, B_CLONE_ADDRESS, + ai.protection, original); + } + } + + proc->pid = pid; + proc->in = NULL; + proc->out = NULL; + proc->err = NULL; + return APR_INCHILD; + } + proc->pid = pid; + proc->in = NULL; + proc->out = NULL; + proc->err = NULL; + return APR_INPARENT; +} + +APR_DECLARE(apr_status_t) apr_procattr_child_errfn_set(apr_procattr_t *attr, + apr_child_errfn_t *errfn) +{ + /* won't ever be called on this platform, so don't save the function pointer */ + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_procattr_error_check_set(apr_procattr_t *attr, + apr_int32_t chk) +{ + /* won't ever be used on this platform, so don't save the flag */ + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_procattr_addrspace_set(apr_procattr_t *attr, + apr_int32_t addrspace) +{ + /* won't ever be used on this platform, so don't save the flag */ + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new, const char *progname, + const char * const *args, + const char * const *env, + apr_procattr_t *attr, + apr_pool_t *pool) +{ + int i=0,nargs=0; + char **newargs = NULL; + thread_id newproc, sender; + struct send_pipe *sp; + char * dir = NULL; + + sp = (struct send_pipe *)apr_palloc(pool, sizeof(struct send_pipe)); + + new->in = attr->parent_in; + new->err = attr->parent_err; + new->out = attr->parent_out; + sp->in = attr->child_in ? attr->child_in->filedes : FILENO_STDIN; + sp->out = attr->child_out ? attr->child_out->filedes : FILENO_STDOUT; + sp->err = attr->child_err ? attr->child_err->filedes : FILENO_STDERR; + + i = 0; + while (args && args[i]) { + i++; + } + + newargs = (char**)malloc(sizeof(char *) * (i + 4)); + newargs[0] = strdup("/boot/home/config/bin/apr_proc_stub"); + if (attr->currdir == NULL) { + /* we require the directory , so use a temp. variable */ + dir = malloc(sizeof(char) * PATH_MAX); + getcwd(dir, PATH_MAX); + newargs[1] = strdup(dir); + free(dir); + } else { + newargs[1] = strdup(attr->currdir); + } + newargs[2] = strdup(progname); + i=0;nargs = 3; + + while (args && args[i]) { + newargs[nargs] = strdup(args[i]); + i++;nargs++; + } + newargs[nargs] = NULL; + + /* ### we should be looking at attr->cmdtype in here... */ + + newproc = load_image(nargs, (const char**)newargs, (const char**)env); + + /* load_image copies the data so now we can free it... */ + while (--nargs >= 0) + free (newargs[nargs]); + free(newargs); + + if (newproc < B_NO_ERROR) { + return errno; + } + + resume_thread(newproc); + + if (attr->child_in && (attr->child_in->filedes != -1)) { + apr_file_close(attr->child_in); + } + if (attr->child_out && (attr->child_in->filedes != -1)) { + apr_file_close(attr->child_out); + } + if (attr->child_err && (attr->child_in->filedes != -1)) { + apr_file_close(attr->child_err); + } + + send_data(newproc, 0, (void*)sp, sizeof(struct send_pipe)); + new->pid = newproc; + + /* before we go charging on we need the new process to get to a + * certain point. When it gets there it'll let us know and we + * can carry on. */ + receive_data(&sender, (void*)NULL,0); + + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc, + int *exitcode, + apr_exit_why_e *exitwhy, + apr_wait_how_e waithow, + apr_pool_t *p) +{ + proc->pid = -1; + return apr_proc_wait(proc, exitcode, exitwhy, waithow); +} + +APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc, + int *exitcode, + apr_exit_why_e *exitwhy, + apr_wait_how_e waithow) +{ + pid_t pstatus; + int waitpid_options = WUNTRACED; + int exit_int; + int ignore; + apr_exit_why_e ignorewhy; + + if (exitcode == NULL) { + exitcode = &ignore; + } + if (exitwhy == NULL) { + exitwhy = &ignorewhy; + } + + if (waithow != APR_WAIT) { + waitpid_options |= WNOHANG; + } + + if ((pstatus = waitpid(proc->pid, &exit_int, waitpid_options)) > 0) { + proc->pid = pstatus; + if (WIFEXITED(exit_int)) { + *exitwhy = APR_PROC_EXIT; + *exitcode = WEXITSTATUS(exit_int); + } + else if (WIFSIGNALED(exit_int)) { + *exitwhy = APR_PROC_SIGNAL; + *exitcode = WTERMSIG(exit_int); + } + else { + + /* unexpected condition */ + return APR_EGENERAL; + } + return APR_CHILD_DONE; + } + else if (pstatus == 0) { + return APR_CHILD_NOTDONE; + } + + return errno; +} + +APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in, + apr_file_t *parent_in) +{ + apr_status_t rv; + + if (attr->child_in == NULL && attr->parent_in == NULL + && child_in == NULL && parent_in == NULL) + if ((rv = apr_file_pipe_create(&attr->child_in, &attr->parent_in, + attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_in); + + if (child_in != NULL && rv == APR_SUCCESS) { + if (attr->child_in && (attr->child_in->filedes != -1)) + rv = apr_file_dup2(attr->child_in, child_in, attr->pool); + else { + attr->child_in = NULL; + if ((rv = apr_file_dup(&attr->child_in, child_in, attr->pool)) + == APR_SUCCESS) + rv = apr_file_inherit_set(attr->child_in); + } + } + + if (parent_in != NULL && rv == APR_SUCCESS) + rv = apr_file_dup(&attr->parent_in, parent_in, attr->pool); + + return rv; +} + +APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out, + apr_file_t *parent_out) +{ + apr_status_t rv; + + if (attr->child_out == NULL && attr->parent_out == NULL + && child_out == NULL && parent_out == NULL) + if ((rv = apr_file_pipe_create(&attr->parent_out, &attr->child_out, + attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_out); + + if (child_out != NULL && rv == APR_SUCCESS) { + if (attr->child_out && (attr->child_out->filedes != -1)) + rv = apr_file_dup2(attr->child_out, child_out, attr->pool); + else { + attr->child_out = NULL; + if ((rv = apr_file_dup(&attr->child_out, child_out, attr->pool)) + == APR_SUCCESS) + rv = apr_file_inherit_set(attr->child_out); + } + } + + if (parent_out != NULL && rv == APR_SUCCESS) + rv = apr_file_dup(&attr->parent_out, parent_out, attr->pool); + + return rv; +} + +APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err, + apr_file_t *parent_err) +{ + apr_status_t rv; + + if (attr->child_err == NULL && attr->parent_err == NULL + && child_err == NULL && parent_err == NULL) + if ((rv = apr_file_pipe_create(&attr->parent_err, &attr->child_err, + attr->pool)) == APR_SUCCESS) + rv = apr_file_inherit_unset(attr->parent_err); + + if (child_err != NULL && rv == APR_SUCCESS) { + if (attr->child_err && (attr->child_err->filedes != -1)) + rv = apr_file_dup2(attr->child_err, child_err, attr->pool); + else { + attr->child_err = NULL; + if ((rv = apr_file_dup(&attr->child_err, child_err, attr->pool)) + == APR_SUCCESS) + rv = apr_file_inherit_set(attr->child_err); + } + } + + if (parent_err != NULL && rv == APR_SUCCESS) + rv = apr_file_dup(&attr->parent_err, parent_err, attr->pool); + + return rv; +} + +APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, + void *limit) +{ + return APR_ENOTIMPL; +} + +APR_DECLARE(apr_status_t) apr_procattr_user_set(apr_procattr_t *attr, + const char *username, + const char *password) +{ + return APR_ENOTIMPL; +} + +APR_DECLARE(apr_status_t) apr_procattr_group_set(apr_procattr_t *attr, + const char *groupname) +{ + return APR_ENOTIMPL; +} + +APR_DECLARE(apr_status_t) apr_procattr_perms_set_register(apr_procattr_t *attr, + apr_perms_setfn_t *perms_set_fn, + void *data, + apr_fileperms_t perms) +{ + return APR_ENOTIMPL; +} diff --git a/threadproc/beos/thread.c b/threadproc/beos/thread.c new file mode 100644 index 0000000..8d83839 --- /dev/null +++ b/threadproc/beos/thread.c @@ -0,0 +1,237 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "apr_arch_threadproc.h" +#include "apr_portable.h" + +APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *pool) +{ + (*new) = (apr_threadattr_t *)apr_palloc(pool, + sizeof(apr_threadattr_t)); + + if ((*new) == NULL) { + return APR_ENOMEM; + } + + (*new)->pool = pool; + (*new)->attr = (int32)B_NORMAL_PRIORITY; + + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on) +{ + if (on == 1){ + attr->detached = 1; + } else { + attr->detached = 0; + } + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr) +{ + if (attr->detached == 1){ + return APR_DETACH; + } + return APR_NOTDETACH; +} + +APR_DECLARE(apr_status_t) apr_threadattr_stacksize_set(apr_threadattr_t *attr, + apr_size_t stacksize) +{ + return APR_ENOTIMPL; +} + +APR_DECLARE(apr_status_t) apr_threadattr_guardsize_set(apr_threadattr_t *attr, + apr_size_t size) +{ + return APR_ENOTIMPL; +} + +static void *dummy_worker(void *opaque) +{ + apr_thread_t *thd = (apr_thread_t*)opaque; + return thd->func(thd, thd->data); +} + +APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr, + apr_thread_start_t func, void *data, + apr_pool_t *pool) +{ + int32 temp; + apr_status_t stat; + + (*new) = (apr_thread_t *)apr_palloc(pool, sizeof(apr_thread_t)); + if ((*new) == NULL) { + return APR_ENOMEM; + } + + (*new)->data = data; + (*new)->func = func; + (*new)->exitval = -1; + + /* First we create the new thread...*/ + if (attr) + temp = attr->attr; + else + temp = B_NORMAL_PRIORITY; + + stat = apr_pool_create(&(*new)->pool, pool); + if (stat != APR_SUCCESS) { + return stat; + } + + (*new)->td = spawn_thread((thread_func)dummy_worker, + "apr thread", + temp, + (*new)); + + /* Now we try to run it...*/ + if (resume_thread((*new)->td) == B_NO_ERROR) { + return APR_SUCCESS; + } + else { + return errno; + } +} + +APR_DECLARE(apr_os_thread_t) apr_os_thread_current(void) +{ + return find_thread(NULL); +} + +int apr_os_thread_equal(apr_os_thread_t tid1, apr_os_thread_t tid2) +{ + return tid1 == tid2; +} + +APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd, apr_status_t retval) +{ + apr_pool_destroy(thd->pool); + thd->exitval = retval; + exit_thread ((status_t)(retval)); + /* This will never be reached... */ + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval, apr_thread_t *thd) +{ + status_t rv = 0, ret; + ret = wait_for_thread(thd->td, &rv); + if (ret == B_NO_ERROR) { + *retval = rv; + return APR_SUCCESS; + } + else { + /* if we've missed the thread's death, did we set an exit value prior + * to it's demise? If we did return that. + */ + if (thd->exitval != -1) { + *retval = thd->exitval; + return APR_SUCCESS; + } else + return ret; + } +} + +APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd) +{ + if (suspend_thread(thd->td) == B_NO_ERROR){ + return APR_SUCCESS; + } + else { + return errno; + } +} + +void apr_thread_yield() +{ +} + +APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key, apr_thread_t *thread) +{ + return apr_pool_userdata_get(data, key, thread->pool); +} + +APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key, + apr_status_t (*cleanup) (void *), + apr_thread_t *thread) +{ + return apr_pool_userdata_set(data, key, cleanup, thread->pool); +} + +APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd) +{ + *thethd = &thd->td; + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, + apr_pool_t *pool) +{ + if (pool == NULL) { + return APR_ENOPOOL; + } + if ((*thd) == NULL) { + (*thd) = (apr_thread_t *)apr_pcalloc(pool, sizeof(apr_thread_t)); + (*thd)->pool = pool; + } + (*thd)->td = *thethd; + return APR_SUCCESS; +} + +static apr_status_t thread_once_cleanup(void *vcontrol) +{ + apr_thread_once_t *control = (apr_thread_once_t *)vcontrol; + + if (control->sem) { + release_sem(control->sem); + delete_sem(control->sem); + } + + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_thread_once_init(apr_thread_once_t **control, + apr_pool_t *p) +{ + int rc; + *control = (apr_thread_once_t *)apr_pcalloc(p, sizeof(apr_thread_once_t)); + (*control)->hit = 0; /* we haven't done it yet... */ + rc = ((*control)->sem = create_sem(1, "thread_once")); + if (rc < 0) + return rc; + + apr_pool_cleanup_register(p, control, thread_once_cleanup, apr_pool_cleanup_null); + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_thread_once(apr_thread_once_t *control, + void (*func)(void)) +{ + if (!control->hit) { + if (acquire_sem(control->sem) == B_OK) { + control->hit = 1; + func(); + } + } + return APR_SUCCESS; +} + +APR_POOL_IMPLEMENT_ACCESSOR(thread) diff --git a/threadproc/beos/threadpriv.c b/threadproc/beos/threadpriv.c new file mode 100644 index 0000000..442235f --- /dev/null +++ b/threadproc/beos/threadpriv.c @@ -0,0 +1,180 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "apr_arch_threadproc.h" + +static struct beos_key key_table[BEOS_MAX_DATAKEYS]; +static struct beos_private_data *beos_data[BEOS_MAX_DATAKEYS]; +static sem_id lock; + +APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key, + void (*dest)(void *), apr_pool_t *pool) +{ + (*key) = (apr_threadkey_t *)apr_palloc(pool, sizeof(apr_threadkey_t)); + if ((*key) == NULL) { + return APR_ENOMEM; + } + + (*key)->pool = pool; + + acquire_sem(lock); + for ((*key)->key=0; (*key)->key < BEOS_MAX_DATAKEYS; (*key)->key++){ + if (key_table[(*key)->key].assigned == 0){ + key_table[(*key)->key].assigned = 1; + key_table[(*key)->key].destructor = dest; + release_sem(lock); + return APR_SUCCESS; + } + + } + release_sem(lock); + return APR_ENOMEM; +} + +APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new, apr_threadkey_t *key) +{ + thread_id tid; + int i, index=0; + tid = find_thread(NULL); + for (i=0;idata){ + /* it's been used */ + if (beos_data[i]->td == tid){ + index = i; + } + } + } + if (index == 0){ + /* no storage for thread so we can't get anything... */ + return APR_ENOMEM; + } + + if ((key->key < BEOS_MAX_DATAKEYS) && (key_table)){ + acquire_sem(key_table[key->key].lock); + if (key_table[key->key].count){ + (*new) = (void*)beos_data[index]->data[key->key]; + } else { + (*new) = NULL; + } + release_sem(key_table[key->key].lock); + } else { + (*new) = NULL; + } + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv, apr_threadkey_t *key) +{ + thread_id tid; + int i,index = 0, ret = 0; + + tid = find_thread(NULL); + for (i=0; i < BEOS_MAX_DATAKEYS; i++){ + if (beos_data[i]->data){ + if (beos_data[i]->td == tid){index = i;} + } + } + if (index==0){ + /* not yet been allocated */ + for (i=0; i< BEOS_MAX_DATAKEYS; i++){ + if (! beos_data[i]->data){ + /* we'll take this one... */ + index = i; + beos_data[i]->data = (const void **)malloc(sizeof(void *) * BEOS_MAX_DATAKEYS); + memset((void *)beos_data[i]->data, 0, sizeof(void *) * BEOS_MAX_DATAKEYS); + beos_data[i]->count = (int)malloc(sizeof(int)); + beos_data[i]->td = (thread_id)malloc(sizeof(thread_id)); + beos_data[i]->td = tid; + } + } + } + if (index == 0){ + /* we're out of luck.. */ + return APR_ENOMEM; + } + if ((key->key < BEOS_MAX_DATAKEYS) && (key_table)){ + acquire_sem(key_table[key->key].lock); + if (key_table[key->key].count){ + if (beos_data[index]->data[key->key] == NULL){ + if (priv != NULL){ + beos_data[index]->count++; + key_table[key->key].count++; + } + } else { + if (priv == NULL){ + beos_data[index]->count--; + key_table[key->key].count--; + } + } + beos_data[index]->data[key->key] = priv; + ret = 1; + } else { + ret = 0; + } + release_sem(key_table[key->key].lock); + } + if (ret) + return APR_SUCCESS; + return APR_ENOMEM; +} + +APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key) +{ + if (key->key < BEOS_MAX_DATAKEYS){ + acquire_sem(key_table[key->key].lock); + if (key_table[key->key].count == 1){ + key_table[key->key].destructor = NULL; + key_table[key->key].count = 0; + } + release_sem(key_table[key->key].lock); + } else { + return APR_ENOMEM; + } + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key, + apr_threadkey_t *threadkey) +{ + return apr_pool_userdata_get(data, key, threadkey->pool); +} + +APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key, + apr_status_t (*cleanup) (void *), + apr_threadkey_t *threadkey) +{ + return apr_pool_userdata_set(data, key, cleanup, threadkey->pool); +} + +APR_DECLARE(apr_status_t) apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key) +{ + *thekey = key->key; + return APR_SUCCESS; +} + +APR_DECLARE(apr_status_t) apr_os_threadkey_put(apr_threadkey_t **key, + apr_os_threadkey_t *thekey, apr_pool_t *pool) +{ + if (pool == NULL) { + return APR_ENOPOOL; + } + if ((*key) == NULL) { + (*key) = (apr_threadkey_t *)apr_pcalloc(pool, sizeof(apr_threadkey_t)); + (*key)->pool = pool; + } + (*key)->key = *thekey; + return APR_SUCCESS; +} diff --git a/threadproc/beos/threadproc_common.c b/threadproc/beos/threadproc_common.c new file mode 100644 index 0000000..95e1625 --- /dev/null +++ b/threadproc/beos/threadproc_common.c @@ -0,0 +1,21 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* As the signal code is identical, use the unix version to reduce + code duplication */ +#include "../unix/signals.c" +#include "../unix/procsup.c" + -- cgit v1.2.3