PUBLIC THREAD *findthread(DEBUG *debug, int id)
{
THREAD *thread;
if ((thread = (THREAD *)SearchList(&debug->threadlist, (WordFnPtr)cmpthread, id)) == NULL)
return newthread(debug, id);
return thread;
}
void child_main(ci_socket sockfd)
{
int claddrlen = sizeof(ci_sockaddr_t);
ci_thread_t thread;
int i, retcode, haschild = 1, jobs_in_queue = 0;
int pid = 0;
char op;
HANDLE hStdin;
DWORD dwRead;
// child_signals();
// pid=getpid();
hStdin = GetStdHandle(STD_INPUT_HANDLE);
if ((hStdin == INVALID_HANDLE_VALUE))
ExitProcess(1);
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
threads_list =
(server_decl_t **) malloc((START_SERVERS + 1) *
sizeof(server_decl_t *));
con_queue = init_queue(START_SERVERS);
for (i = 0; i < START_SERVERS; i++) {
if ((threads_list[i] = newthread(con_queue)) == NULL) {
exit(-1); // FATAL error.....
}
retcode = ci_thread_create(&thread,
(void *(*)(void *)) thread_main,
(void *) threads_list[i]);
}
threads_list[START_SERVERS] = NULL;
ci_debug_printf(1, "Threads created ....\n");
retcode = ci_thread_create(&worker_thread,
(void *(*)(void *)) worker_main,
(void *) (sockfd));
//Listen for events from main server better..............
while (ReadFile(hStdin, &op, 1, &dwRead, NULL)) {
printf("Operation Read: %c\n", op);
if (op == 'q')
goto end_child_main;
}
ci_thread_join(worker_thread);
end_child_main:
cancel_all_threads();
exit_normaly();
}
int main(int argc, char *argv[])
{
void *result;
char *data = strdup("Hello world!\n");
struct thread_info *ti = newthread(hello_thread);
// Send one line of text.
thread_send(ti, data, strlen(data));
// Signal thread to exit and wait for it to do so.
thread_send(ti, NULL, 1);
pthread_join(ti->thread, &result);
return (long)result;
}
/*
* Create and initialize a new Proc structure with a single Thread
* running inside it. Add the Proc to the global process list.
*/
Proc*
_newproc(void (*f)(void *arg), void *arg, uint stacksize, char *name, int grp, int rforkflag)
{
Proc *p;
p = _threadmalloc(sizeof *p, 1);
p->pid = -1;
p->rforkflag = rforkflag;
newthread(p, f, arg, stacksize, name, grp);
lock(&_threadpq.lock);
if(_threadpq.head == nil)
_threadpq.head = p;
else
*_threadpq.tail = p;
_threadpq.tail = &p->next;
unlock(&_threadpq.lock);
return p;
}
/*
* Create a new thread and schedule it to run.
* The thread grp is inherited from the currently running thread.
*/
int
threadcreate(void (*f)(void *arg), void *arg, uint stacksize)
{
return newthread(_threadgetproc(), f, arg, stacksize, nil, threadgetgrp());
}
void child_main(int sockfd, int pipefd)
{
ci_thread_t thread;
int i, ret;
signal(SIGTERM, SIG_IGN); /*Ignore parent requests to kill us untill we are up and running */
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
ci_stat_attach_mem(child_data->stats, child_data->stats_size, NULL);
threads_list =
(server_decl_t **) malloc((CONF.THREADS_PER_CHILD + 1) *
sizeof(server_decl_t *));
con_queue = init_queue(CONF.THREADS_PER_CHILD);
for (i = 0; i < CONF.THREADS_PER_CHILD; i++) {
if ((threads_list[i] = newthread(con_queue)) == NULL) {
exit(-1); // FATAL error.....
}
ret =
ci_thread_create(&thread, (void *(*)(void *)) thread_main,
(void *) threads_list[i]);
threads_list[i]->srv_pthread = thread;
}
threads_list[CONF.THREADS_PER_CHILD] = NULL;
/*Now start the listener thread.... */
ret = ci_thread_create(&thread, (void *(*)(void *)) listener_thread,
(void *) &sockfd);
listener_thread_id = thread;
/*set srand for child......*/
srand(((unsigned int)time(NULL)) + (unsigned int)getpid());
/*I suppose that all my threads are up now. We can setup our signal handlers */
child_signals();
/* A signal from parent may comes while we are starting.
Listener will not accept any request in this case, (it checks on
the beggining of the accept loop for parent commands) so we can
shutdown imediatelly even if the parent said gracefuly.*/
if (child_data->father_said)
child_data->to_be_killed = IMMEDIATELY;
/*start child commands may have non thread safe code but the worker threads
does not serving requests yet.*/
commands_execute_start_child();
/*Signal listener to start accepting requests.*/
int doStart = 0;
do {
ci_thread_mutex_lock(&counters_mtx);
doStart = listener_running;
ci_thread_mutex_unlock(&counters_mtx);
if (!doStart)
ci_usleep(5);
} while(!doStart);
ci_thread_cond_signal(&free_server_cond);
while (!child_data->to_be_killed) {
char buf[512];
int bytes;
if ((ret = ci_wait_for_data(pipefd, 1, wait_for_read)) > 0) { /*data input */
bytes = ci_read_nonblock(pipefd, buf, 511);
if (bytes == 0) {
ci_debug_printf(1,
"Parent closed the pipe connection! Going to term immediately!\n");
child_data->to_be_killed = IMMEDIATELY;
} else {
buf[bytes] = '\0';
handle_child_process_commands(buf);
}
}
else if (ret < 0) {
ci_debug_printf(1,
"An error occured while waiting for commands from parent. Terminating!\n");
child_data->to_be_killed = IMMEDIATELY;
}
if (!listener_running && !child_data->to_be_killed) {
ci_debug_printf(1,
"Ohh!! something happened to listener thread! Terminating\n");
child_data->to_be_killed = GRACEFULLY;
}
commands_exec_scheduled();
}
ci_debug_printf(5, "Child :%d going down :%s\n", getpid(),
child_data->to_be_killed == IMMEDIATELY?
"IMMEDIATELY" : "GRACEFULLY");
cancel_all_threads();
commands_execute_stop_child();
exit_normaly();
}
void child_main(int sockfd){
ci_connection_t conn;
int claddrlen=sizeof(struct sockaddr_in);
ci_thread_t thread;
char clientname[300];
int i,retcode,haschild=1,jobs_in_queue=0;
int pid=0;
child_signals();
pid=getpid();
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
threads_list=(server_decl_t **)malloc((START_SERVERS+1)*sizeof(server_decl_t *));
con_queue=init_queue(START_SERVERS);
for(i=0;i<START_SERVERS;i++){
if((threads_list[i]=newthread(con_queue))==NULL){
exit(-1);// FATAL error.....
}
retcode=ci_thread_create(&thread,(void *(*)(void *))thread_main,(void *)threads_list[i]);
}
threads_list[START_SERVERS]=NULL;
for(;;){ //Global for
if(!ci_proc_mutex_lock(&accept_mutex)){
if(errno==EINTR){
debug_printf(5,"EINTR received\n");
if(child_data->to_be_killed)
goto end_child_main;
continue;
}
}
child_data->idle=0;
debug_printf(7,"Child %d getting requests now ...\n",pid);
do{//Getting requests while we have free servers.....
do{
errno = 0;
if(((conn.fd = accept(sockfd, (struct sockaddr *)&(conn.claddr), &claddrlen)) == -1) && errno != EINTR){
debug_printf(1,"error accept .... %d\nExiting server ....\n",errno);
exit(-1); //For the moment .......
goto end_child_main ;
}
if(errno==EINTR && child_data->to_be_killed)
goto end_child_main;
}while(errno==EINTR);
getsockname(conn.fd,(struct sockaddr *)&(conn.srvaddr),&claddrlen);
icap_socket_opts(sockfd);
if((jobs_in_queue=put_to_queue(con_queue,&conn))==0){
debug_printf(1,"ERROR!!!!!!NO AVAILABLE SERVERS!!!!!!!!!\n");
child_data->to_be_killed=GRACEFULLY;
debug_printf(1,"Jobs in Queue:%d,Free servers:%d, Used Servers :%d, Requests %d\n",
jobs_in_queue,
child_data->freeservers,child_data->usedservers,child_data->requests);
goto end_child_main;
}
ci_thread_mutex_lock(&counters_mtx);
haschild=(child_data->freeservers?1:0);
ci_thread_mutex_unlock(&counters_mtx);
(child_data->connections)++; //NUM of Requests....
}while(haschild);
child_data->idle=1;
ci_proc_mutex_unlock(&accept_mutex);
ci_thread_mutex_lock(&counters_mtx);
if(child_data->freeservers==0){
debug_printf(7,"Child %d waiting for a thread to accept more connections ...\n",pid);
ci_thread_cond_wait(&free_server_cond,&counters_mtx);
}
ci_thread_mutex_unlock(&counters_mtx);
}
end_child_main:
cancel_all_threads();
exit_normaly();
}
