extern char* getenv();
#include <time.h>
#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
#if !defined(USE_PTHREADS) && !defined(USE_SOLARIS_THREADS)
#ifdef AFS_OSF_ENV
static struct lwp_ctl *lwp_init = 0;
-int LWP_QWait()
+int LWP_QWait(void)
{register PROCESS tp;
(tp=lwp_cpptr) -> status = QWAITING;
lwp_remove(tp, &runnable[tp->priority]);
}
#ifdef AFS_AIX32_ENV
-char *reserveFromStack(size)
- register afs_int32 size;
+char *reserveFromStack(register afs_int32 size)
{
char *x;
x = alloca(size);
}
#endif
-int LWP_CreateProcess(ep, stacksize, priority, parm, name, pid)
- int (*ep)();
- int stacksize, priority;
- char *parm;
- char *name;
- PROCESS *pid;
+int LWP_CreateProcess(int (*ep)(), int stacksize, int priority,
+ char *parm, char *name, PROCESS *pid)
{
PROCESS temp, temp2;
#ifdef AFS_AIX32_ENV
}
#ifdef AFS_AIX32_ENV
-int LWP_CreateProcess2(ep, stacksize, priority, parm, name, pid)
- int (*ep)();
- int stacksize, priority;
- char *parm;
- char *name;
- PROCESS *pid;
+int LWP_CreateProcess2(int (*ep)(), int stacksize, int priority,
+ char *parm, char *name, PROCESS *pid)
{
PROCESS temp, temp2;
char *stackptr;
}
#endif
-int LWP_CurrentProcess(pid) /* returns pid of current process */
- PROCESS *pid;
+int LWP_CurrentProcess(PROCESS *pid) /* returns pid of current process */
{
Debug(0, ("Entered Current_Process"))
if (lwp_init) {
return LWP_EINIT;
}
-PROCESS LWP_ThreadId()
+PROCESS LWP_ThreadId(void)
{
Debug(0, ("Entered ThreadId"))
if (lwp_init)
#define LWPANCHOR (*lwp_init)
-int LWP_DestroyProcess(pid) /* destroy a lightweight process */
- PROCESS pid;
+int LWP_DestroyProcess(PROCESS pid) /* destroy a lightweight process */
{
PROCESS temp;
return LWP_EINIT;
}
-int LWP_DispatchProcess() /* explicit voluntary preemption */
+int LWP_DispatchProcess(void) /* explicit voluntary preemption */
{
Debug(2, ("Entered Dispatch_Process"))
if (lwp_init) {
}
#ifdef DEBUG
-int Dump_Processes()
+int Dump_Processes(void)
{
if (lwp_init) {
register int i;
}
#endif
-int LWP_GetProcessPriority(pid, priority) /* returns process priority */
- PROCESS pid;
- int *priority;
+int LWP_GetProcessPriority(PROCESS pid, int *priority) /* returns process priority */
{
Debug(0, ("Entered Get_Process_Priority"))
if (lwp_init) {
return LWP_EINIT;
}
-int LWP_InitializeProcessSupport(priority, pid)
- int priority;
- PROCESS *pid;
+int LWP_InitializeProcessSupport(int priority, PROCESS *pid)
{
PROCESS temp;
struct lwp_pcb dummy;
return LWP_SUCCESS;
}
-int LWP_INTERNALSIGNAL(event, yield) /* signal the occurence of an event */
- char *event;
- int yield;
+int LWP_INTERNALSIGNAL(char *event, int yield) /* signal the occurence of an event */
{
Debug(2, ("Entered LWP_SignalProcess"))
if (lwp_init) {
return LWP_EINIT;
}
-int LWP_TerminateProcessSupport() /* terminate all LWP support */
+int LWP_TerminateProcessSupport(void) /* terminate all LWP support */
{
register int i;
return LWP_SUCCESS;
}
-int LWP_WaitProcess(event) /* wait on a single event */
- char *event;
+int LWP_WaitProcess(char *event) /* wait on a single event */
{
char *tempev[2];
return LWP_MwaitProcess(1, tempev);
}
-int LWP_MwaitProcess(wcount, evlist) /* wait on m of n events */
- int wcount;
- char *evlist[];
+int LWP_MwaitProcess(int wcount, char *evlist[]) /* wait on m of n events */
{
register int ecount, i;
return LWP_EINIT;
}
-int LWP_StackUsed(pid, maxa, used)
- PROCESS pid;
- int *maxa, *used;
+int LWP_StackUsed(PROCESS pid, int *maxa, int *used)
{
*maxa = pid -> stacksize;
*used = Stack_Used(pid->stack, *maxa);
* INTERNAL to the LWP support package.
*/
-static void Abort_LWP(msg)
- char *msg;
+static void Abort_LWP(char *msg)
{
struct lwp_context tempcontext;
return;
}
-static int Create_Process_Part2 () /* creates a context for the new process */
+static int Create_Process_Part2(void) /* creates a context for the new process */
{
PROCESS temp;
return 0;
}
-static int Delete_PCB(pid) /* remove a PCB from the process list */
- register PROCESS pid;
+static int Delete_PCB(register PROCESS pid) /* remove a PCB from the process list */
{
Debug(4, ("Entered Delete_PCB"))
lwp_remove(pid, (pid->blockflag || pid->status==WAITING || pid->status==DESTROYED
}
#ifdef DEBUG
-static int Dump_One_Process(pid)
- PROCESS pid;
+static int Dump_One_Process(PROCESS pid)
{
int i;
}
#endif
-static int purge_dead_pcbs()
+static int purge_dead_pcbs(void)
{
for_all_elts(cur, blocked, { if (cur->status == DESTROYED) Dispose_of_Dead_PCB(cur); })
return 0;
int LWP_TraceProcesses = 0;
-static int Dispatcher() /* Lightweight process dispatcher */
+static int Dispatcher(void) /* Lightweight process dispatcher */
{
register int i;
#ifdef DEBUG
}
/* Complain of a stack overflow to stderr without using stdio. */
-static void Overflow_Complain ()
+static void Overflow_Complain(void)
{
time_t currenttime;
char *timeStamp;
write (2, msg2, strlen(msg2));
}
-static void Dispose_of_Dead_PCB (cur)
- PROCESS cur;
+static void Dispose_of_Dead_PCB (PROCESS cur)
{
Debug(4, ("Entered Dispose_of_Dead_PCB"))
Delete_PCB(cur);
*/
}
-static int Exit_LWP()
+static int Exit_LWP(void)
{
abort();
}
-static void Free_PCB(pid)
- PROCESS pid;
+static void Free_PCB(PROCESS pid)
{
Debug(4, ("Entered Free_PCB"))
if (pid -> stack != NULL) {
free(pid);
}
-static void Initialize_PCB(temp, priority, stack, stacksize, ep, parm, name)
- PROCESS temp;
- int (*ep)();
- int stacksize, priority;
- char *parm;
- char *name,*stack;
+static void Initialize_PCB(PROCESS temp, int priority, char *stack,
+ int stacksize, int (*ep)(), char *parm, char *name)
{
register int i = 0;
temp -> level = 1; /* non-preemptable */
}
-static int Internal_Signal(event)
- register char *event;
+static int Internal_Signal(register char *event)
{
int rc = LWP_ENOWAIT;
register int i;
/* This can be any unlikely pattern except 0x00010203 or the reverse. */
#define STACKMAGIC 0xBADBADBA
-static afs_int32 Initialize_Stack(stackptr, stacksize)
- char *stackptr;
- int stacksize;
+static afs_int32 Initialize_Stack(char *stackptr, int stacksize)
{
register int i;
return 0;
}
-static int Stack_Used(stackptr, stacksize)
- register char *stackptr;
- int stacksize;
+static int Stack_Used(register char *stackptr, int stacksize)
{
register int i;
}
-LWP_NewRock(Tag, Value)
- int Tag; /* IN */
- char *Value; /* IN */
+int LWP_NewRock(int Tag, char *Value)
/* Finds a free rock and sets its value to Value.
Return codes:
LWP_SUCCESS Rock did not exist and a new one was used
}
-LWP_GetRock(Tag, Value)
- int Tag; /* IN */
- char **Value; /* OUT */
-
+int LWP_GetRock(int Tag, char **Value)
/* Obtains the pointer Value associated with the rock Tag of this LWP.
Returns:
LWP_SUCCESS if specified rock exists and Value has been filled
#ifdef AFS_AIX32_ENV
-setlim(limcon, hard, limit)
- int limcon;
- uchar_t hard;
+int setlim(int limcon, uchar_t hard, int limit)
{
struct rlimit rlim;
/*
* Print the specific limit out
*/
-plim(name, lc, hard)
- char *name;
- afs_int32 lc;
- uchar_t hard;
+int plim(char *name, afs_int32 lc, uchar_t hard)
{
struct rlimit rlim;
int lim;
#endif
#ifdef AFS_SUN5_ENV
-int LWP_NoYieldSignal(event)
- char *event;
+int LWP_NoYieldSignal(char *event)
{
return (LWP_INTERNALSIGNAL(event, 0));
}
-int LWP_SignalProcess(event)
- char *event;
+int LWP_SignalProcess(char *event)
{
return (LWP_INTERNALSIGNAL(event, 1));
}
#define hash(event) ((unsigned long) (event) % HASHSIZE);
#if CMA_DEBUG || DEBUGF
-char *lwp_process_string() {
+char *lwp_process_string(void)
+{
static char id[200];
PROCESS p;
LWP_CurrentProcess(&p);
}
#endif
-void lwp_unimplemented(interface)
- char *interface;
+void lwp_unimplemented(char *interface)
{
fprintf(stderr, "cmalwp: %s is not currently implemented: program aborted\n",
interface);
exit(1);
}
-static lwpabort(interface)
- char *interface;
+static void lwpabort(char *interface)
{
fprintf(stderr, "cmalwp: %s failed unexpectedly\n", interface);
abort();
}
-int LWP_QWait()
+int LWP_QWait(void)
{
lwp_unimplemented("LWP_QWait");
}
-int LWP_QSignal(pid)
+int LWP_QSignal(int pid)
{
lwp_unimplemented("LWP_QSignal");
}
/* Allocate and initialize an LWP process handle. The associated pthread handle
* must be added by the caller, and the structure threaded onto the LWP active
* process list by lwp_thread_process */
-static PROCESS lwp_alloc_process(name, ep, arg)
- char *name;
- pthread_startroutine_t ep;
- pthread_addr_t arg;
+static PROCESS lwp_alloc_process(char *name,
+ pthread_startroutine_t ep, pthread_addr_t arg)
{
PROCESS lp;
assert(lp = (PROCESS) malloc(sizeof (*lp)));
/* Thread the LWP process descriptor *lp onto the lwp active process list
* and associate a back pointer to the process descriptor from the associated
* thread */
-static lwp_thread_process(lp)
- PROCESS lp;
+static lwp_thread_process(PROCESS lp)
{
lp->next = lwp_process_list;
lwp_process_list = lp;
/* The top-level routine used as entry point to explicitly created LWP
* processes. This completes a few details of process creation left
* out by LWP_CreateProcess and calls the user-specified entry point */
-static int lwp_top_level(argp)
- pthread_addr_t argp;
+static int lwp_top_level(pthread_addr_t argp)
{
PROCESS lp = (PROCESS) argp;
/* Should cleanup state */
}
-int LWP_CreateProcess(ep, stacksize, priority, parm, name, pid)
- int (*ep)();
- int stacksize, priority;
- char *parm;
- char *name;
- PROCESS *pid;
+int LWP_CreateProcess(pthread_startroutine_t ep, int stacksize, int priority,
+ char *parm, char *name, PROCESS *pid)
{
int status;
pthread_attr_t attr;
return LWP_SUCCESS;
}
-PROCESS LWP_ActiveProcess() { /* returns pid of current process */
+PROCESS LWP_ActiveProcess(void)
+{ /* returns pid of current process */
PROCESS pid;
assert(!pthread_getspecific(lwp_process_key, (pthread_addr_t *) &pid));
return pid;
}
-int LWP_CurrentProcess(pid) /* get pid of current process */
- PROCESS *pid;
+int LWP_CurrentProcess(PROCESS *pid) /* get pid of current process */
{
assert(!pthread_getspecific(lwp_process_key, (pthread_addr_t *) pid));
return LWP_SUCCESS;
}
-int LWP_DestroyProcess(pid) /* destroy a lightweight process */
- PROCESS pid;
+int LWP_DestroyProcess(PROCESS pid) /* destroy a lightweight process */
{
lwp_unimplemented("LWP_DestroyProcess");
}
-int LWP_DispatchProcess() /* explicit voluntary preemption */
+int LWP_DispatchProcess(void) /* explicit voluntary preemption */
{
assert(!pthread_mutex_unlock(&lwp_mutex));
pthread_yield();
return LWP_SUCCESS;
}
-static int lwp_process_key_destructor() {}
+static int lwp_process_key_destructor(void)
+{
+}
-int LWP_InitializeProcessSupport(priority, pid)
- int priority;
- PROCESS *pid;
+int LWP_InitializeProcessSupport(int priority, PROCESS *pid)
{
static int initialized = 0;
int status;
return LWP_SUCCESS;
}
-int LWP_TerminateProcessSupport() /* terminate all LWP support */
+int LWP_TerminateProcessSupport(void) /* terminate all LWP support */
{
lwp_unimplemented("LWP_TerminateProcessSupport");
}
/* Get and initialize event structure corresponding to lwp event (i.e. address) */
-static event_t *getevent(event)
- char *event;
+static event_t *getevent(char *event)
{
event_t *evp, *newp;
int hashcode;
/* Release the specified event */
#define relevent(evp) ((evp)->refcount--)
-int LWP_WaitProcess(event) /* wait on a single event */
- char *event;
+int LWP_WaitProcess(char *event) /* wait on a single event */
{
struct event *ev;
int seq;
return LWP_SUCCESS;
}
-int LWP_MwaitProcess(wcount, evlist) /* wait on m of n events */
- int wcount;
- char *evlist[];
+int LWP_MwaitProcess(int wcount, char *evlist[]) /* wait on m of n events */
{
lwp_unimplemented("LWP_MWaitProcess");
}
-int LWP_NoYieldSignal(event)
- char *event;
+int LWP_NoYieldSignal(char *event)
{
struct event *ev;
debugf(("%s: no yield signal (%x)\n", lwp_process_string(), event));
return LWP_SUCCESS;
}
-int LWP_SignalProcess(event)
- char *event;
+int LWP_SignalProcess(char *event)
{
struct event *ev;
debugf(("%s: signal process (%x)\n", lwp_process_string(), event));
return LWP_SUCCESS;
}
-int LWP_StackUsed(pid, maxa, used)
- PROCESS pid;
- int *maxa, *used;
+int LWP_StackUsed(PROCESS pid, int *maxa, int *used)
{
lwp_unimplemented("LWP_StackUsed");
}
-LWP_NewRock(Tag, Value)
- int Tag; /* IN */
- char *Value; /* IN */
+int LWP_NewRock(int Tag, char *Value)
{
lwp_unimplemented("LWP_NewRock");
}
-LWP_GetRock(Tag, Value)
- int Tag; /* IN */
- char **Value; /* OUT */
+int LWP_GetRock(int Tag, char **Value)
{
lwp_unimplemented("LWP_GetRock");
}
-int LWP_GetProcessPriority(pid, priority) /* returns process priority */
- PROCESS pid;
- int *priority;
+int LWP_GetProcessPriority(PROCESS pid, int *priority) /* returns process priority */
{
lwp_unimplemented("LWP_GetProcessPriority");
}
git://git.openafs.org / openafs.git / blobdiff