From 7e253321ed299ef0c3c9be3a2cd8114e10fae4f7 Mon Sep 17 00:00:00 2001 From: miker Date: Mon, 7 Jan 2008 02:11:47 +0000 Subject: [PATCH 1/1] Patch from Scott McKellar: 1. I moved almost everything from the header file into the implementation file, since it isn't referenced elsewhere. All that's left is one function prototype and a series of nested #includes. 2. I added compilation guards to the header. 3. Except for osrf_prefork_run(), all functions are now static, as is the child_dead variable. 4. I commented out the MAX_BUFSIZE macro, since it isn't used. 5. I removed the declaration of main(), which seemed rather pointless. 6. I added the const qualifier to the parameters of osrf_prefork_run() and osrf_prefork_routers(). 7. I made sure that all members were explicitly initialized when creating a prefork_simple or a prefork_child. 8. I commented out both the prototype and the definition of find_prefork_child(), since we don't call it anywhere. git-svn-id: svn://svn.open-ils.org/OpenSRF/trunk@1210 9efc2488-bf62-4759-914b-345cdb29e865 --- include/opensrf/osrf_prefork.h | 72 ++---------------- src/libopensrf/osrf_prefork.c | 133 +++++++++++++++++++++++++-------- 2 files changed, 107 insertions(+), 98 deletions(-) diff --git a/include/opensrf/osrf_prefork.h b/include/opensrf/osrf_prefork.h index 543343c..a314da9 100644 --- a/include/opensrf/osrf_prefork.h +++ b/include/opensrf/osrf_prefork.h @@ -1,3 +1,6 @@ +#ifndef OSRF_PREFORK_H +#define OSRF_PREFORK_H + #include #include #include @@ -14,10 +17,6 @@ #include #include -//#define READ_BUFSIZE 4096 -#define READ_BUFSIZE 1024 -#define MAX_BUFSIZE 10485760 /* 10M enough? ;) */ -#define ABS_MAX_CHILDREN 256 /* we receive data. we find the next child in line that is available. pass the data down that childs pipe and go @@ -30,67 +29,6 @@ data to the parent to alert the parent that the child is again available */ -struct prefork_simple_struct { - int max_requests; - int min_children; - int max_children; - int fd; - int data_to_child; - int data_to_parent; - int current_num_children; - int keepalive; /* keepalive time for stateful sessions */ - char* appname; - struct prefork_child_struct* first_child; - transport_client* connection; -}; -typedef struct prefork_simple_struct prefork_simple; - -struct prefork_child_struct { - pid_t pid; - int read_data_fd; - int write_data_fd; - int read_status_fd; - int write_status_fd; - int min_children; - int available; - int max_requests; - char* appname; - int keepalive; - struct prefork_child_struct* next; -}; - -typedef struct prefork_child_struct prefork_child; - -int osrf_prefork_run(char* appname); - -prefork_simple* prefork_simple_init( transport_client* client, - int max_requests, int min_children, int max_children ); - -prefork_child* launch_child( prefork_simple* forker ); -void prefork_launch_children( prefork_simple* forker ); - -void prefork_run(prefork_simple* forker); - -void add_prefork_child( prefork_simple* forker, prefork_child* child ); -prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid ); -void del_prefork_child( prefork_simple* forker, pid_t pid ); - -void check_children( prefork_simple* forker, int forever ); - -void prefork_child_process_request(prefork_child*, char* data); -int prefork_child_init_hook(prefork_child*); - -prefork_child* prefork_child_init( - int max_requests, int read_data_fd, int write_data_fd, - int read_status_fd, int write_status_fd ); - -/* listens on the 'data_to_child' fd and wait for incoming data */ -void prefork_child_wait( prefork_child* child ); - -int prefork_free( prefork_simple* ); -int prefork_child_free( prefork_child* ); - - -void osrf_prefork_register_routers( char* appname ); +int osrf_prefork_run(const char* appname); -void osrf_prefork_child_exit( prefork_child* ); +#endif diff --git a/src/libopensrf/osrf_prefork.c b/src/libopensrf/osrf_prefork.c index 68af4aa..a5d5794 100644 --- a/src/libopensrf/osrf_prefork.c +++ b/src/libopensrf/osrf_prefork.c @@ -3,14 +3,74 @@ #include #include +//#define READ_BUFSIZE 4096 +#define READ_BUFSIZE 1024 +//#define MAX_BUFSIZE 10485760 /* 10M enough? ;) */ +#define ABS_MAX_CHILDREN 256 + +struct prefork_simple_struct { + int max_requests; + int min_children; + int max_children; + int fd; + int data_to_child; + int data_to_parent; + int current_num_children; + int keepalive; /* keepalive time for stateful sessions */ + char* appname; + struct prefork_child_struct* first_child; + transport_client* connection; +}; +typedef struct prefork_simple_struct prefork_simple; + +struct prefork_child_struct { + pid_t pid; + int read_data_fd; + int write_data_fd; + int read_status_fd; + int write_status_fd; + int min_children; + int available; + int max_requests; + char* appname; + int keepalive; + struct prefork_child_struct* next; +}; + +typedef struct prefork_child_struct prefork_child; + +static prefork_simple* prefork_simple_init( transport_client* client, + int max_requests, int min_children, int max_children ); +static prefork_child* launch_child( prefork_simple* forker ); +static void prefork_launch_children( prefork_simple* forker ); +static void prefork_run(prefork_simple* forker); +static void add_prefork_child( prefork_simple* forker, prefork_child* child ); + +//static prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid ); + +static void del_prefork_child( prefork_simple* forker, pid_t pid ); +static void check_children( prefork_simple* forker, int forever ); +static void prefork_child_process_request(prefork_child*, char* data); +static int prefork_child_init_hook(prefork_child*); +static prefork_child* prefork_child_init( + int max_requests, int read_data_fd, int write_data_fd, + int read_status_fd, int write_status_fd ); + +/* listens on the 'data_to_child' fd and wait for incoming data */ +static void prefork_child_wait( prefork_child* child ); +static int prefork_free( prefork_simple* ); +static int prefork_child_free( prefork_child* ); +static void osrf_prefork_register_routers( const char* appname ); +static void osrf_prefork_child_exit( prefork_child* ); + + /* true if we just deleted a child. This will allow us to make sure we're not trying to use freed memory */ -int child_dead; +static int child_dead; -int main(); -void sigchld_handler( int sig ); +static void sigchld_handler( int sig ); -int osrf_prefork_run(char* appname) { +int osrf_prefork_run(const char* appname) { if(!appname) { osrfLogError( OSRF_LOG_MARK, "osrf_prefork_run requires an appname to run!"); @@ -83,7 +143,7 @@ int osrf_prefork_run(char* appname) { } -void osrf_prefork_register_routers( char* appname ) { +static void osrf_prefork_register_routers( const char* appname ) { osrfStringArray* arr = osrfNewStringArray(4); @@ -113,7 +173,7 @@ void osrf_prefork_register_routers( char* appname ) { osrfStringArrayFree(arr); } -int prefork_child_init_hook(prefork_child* child) { +static int prefork_child_init_hook(prefork_child* child) { if(!child) return -1; osrfLogDebug( OSRF_LOG_MARK, "Child init hook for child %d", child->pid); @@ -149,7 +209,7 @@ int prefork_child_init_hook(prefork_child* child) { return 0; } -void prefork_child_process_request(prefork_child* child, char* data) { +static void prefork_child_process_request(prefork_child* child, char* data) { if( !child ) return; transport_client* client = osrfSystemGetTransportClient(); @@ -220,7 +280,7 @@ void prefork_child_process_request(prefork_child* child, char* data) { } -prefork_simple* prefork_simple_init( transport_client* client, +static prefork_simple* prefork_simple_init( transport_client* client, int max_requests, int min_children, int max_children ) { if( min_children > max_children ) { @@ -243,13 +303,19 @@ prefork_simple* prefork_simple_init( transport_client* client, prefork->max_requests = max_requests; prefork->min_children = min_children; prefork->max_children = max_children; + prefork->fd = 0; + prefork->data_to_child = 0; + prefork->data_to_parent = 0; + prefork->current_num_children = 0; + prefork->keepalive = 0; + prefork->appname = NULL; prefork->first_child = NULL; prefork->connection = client; return prefork; } -prefork_child* launch_child( prefork_simple* forker ) { +static prefork_child* launch_child( prefork_simple* forker ) { pid_t pid; int data_fd[2]; @@ -315,12 +381,12 @@ prefork_child* launch_child( prefork_simple* forker ) { return NULL; } -void osrf_prefork_child_exit(prefork_child* child) { +static void osrf_prefork_child_exit(prefork_child* child) { osrfAppRunExitCode(); exit(0); } -void prefork_launch_children( prefork_simple* forker ) { +static void prefork_launch_children( prefork_simple* forker ) { if(!forker) return; int c = 0; while( c++ < forker->min_children ) @@ -328,7 +394,7 @@ void prefork_launch_children( prefork_simple* forker ) { } -void sigchld_handler( int sig ) { +static void sigchld_handler( int sig ) { signal(SIGCHLD, sigchld_handler); child_dead = 1; } @@ -349,7 +415,7 @@ void reap_children( prefork_simple* forker ) { child_dead = 0; } -void prefork_run(prefork_simple* forker) { +static void prefork_run(prefork_simple* forker) { if( forker->first_child == NULL ) return; @@ -477,7 +543,7 @@ void prefork_run(prefork_simple* forker) { * in the worst case it won't be slower and will do less logging... */ -void check_children( prefork_simple* forker, int forever ) { +static void check_children( prefork_simple* forker, int forever ) { //check_begin: @@ -554,7 +620,7 @@ void check_children( prefork_simple* forker, int forever ) { } -void prefork_child_wait( prefork_child* child ) { +static void prefork_child_wait( prefork_child* child ) { int i,n; growing_buffer* gbuf = buffer_init( READ_BUFSIZE ); @@ -606,7 +672,7 @@ void prefork_child_wait( prefork_child* child ) { } -void add_prefork_child( prefork_simple* forker, prefork_child* child ) { +static void add_prefork_child( prefork_simple* forker, prefork_child* child ) { if( forker->first_child == NULL ) { forker->first_child = child; @@ -634,20 +700,20 @@ void add_prefork_child( prefork_simple* forker, prefork_child* child ) { return; } -prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid ) { - - if( forker->first_child == NULL ) { return NULL; } - prefork_child* start_child = forker->first_child; - do { - if( forker->first_child->pid == pid ) - return forker->first_child; - } while( (forker->first_child = forker->first_child->next) != start_child ); - - return NULL; -} +//static prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid ) { +// +// if( forker->first_child == NULL ) { return NULL; } +// prefork_child* start_child = forker->first_child; +// do { +// if( forker->first_child->pid == pid ) +// return forker->first_child; +// } while( (forker->first_child = forker->first_child->next) != start_child ); +// +// return NULL; +//} -void del_prefork_child( prefork_simple* forker, pid_t pid ) { +static void del_prefork_child( prefork_simple* forker, pid_t pid ) { if( forker->first_child == NULL ) { return; } @@ -718,23 +784,28 @@ void del_prefork_child( prefork_simple* forker, pid_t pid ) { -prefork_child* prefork_child_init( +static prefork_child* prefork_child_init( int max_requests, int read_data_fd, int write_data_fd, int read_status_fd, int write_status_fd ) { prefork_child* child = (prefork_child*) safe_malloc(sizeof(prefork_child)); + child->pid = 0; child->max_requests = max_requests; child->read_data_fd = read_data_fd; child->write_data_fd = write_data_fd; child->read_status_fd = read_status_fd; child->write_status_fd = write_status_fd; + child->min_children = 0; child->available = 1; + child->appname = NULL; + child->keepalive = 0; + child->next = NULL; return child; } -int prefork_free( prefork_simple* prefork ) { +static int prefork_free( prefork_simple* prefork ) { while( prefork->first_child != NULL ) { osrfLogInfo( OSRF_LOG_MARK, "Killing children and sleeping 1 to reap..." ); @@ -748,7 +819,7 @@ int prefork_free( prefork_simple* prefork ) { return 1; } -int prefork_child_free( prefork_child* child ) { +static int prefork_child_free( prefork_child* child ) { free(child->appname); close(child->read_data_fd); close(child->write_status_fd); -- 2.43.2