procmgmt: config
${COMPILE_PART1} procmgmt ${COMPILE_PART2}
-util: procmgmt des
+util: procmgmt des lwp_depinstall
${COMPILE_PART1} util ${COMPILE_PART2}
audit: util rx rxkad
/*
* Donate this process to Rx.
*/
- rx_ServerProc();
+ rx_ServerProc(NULL);
return (0);
} /*afs_RXCallBackServer */
}
/* bnode lwp executes this code repeatedly */
-static int
-bproc()
+static void *
+bproc(void *unused)
{
register afs_int32 code;
register struct bnode *tb;
}
}
}
+ return NULL;
}
static afs_int32
/* Called by IOMGR at low priority on IOMGR's stack shortly after a SIGCHLD
* occurs. Wakes up bproc do redo things */
-int
-bnode_SoftInt(int asignal)
+void *
+bnode_SoftInt(void *param)
{
+ /* int asignal = (int) param; */
+
IOMGR_Cancel(bproc_pid);
return 0;
}
void
bnode_Int(int asignal)
{
- extern void bozo_ShutdownAndExit();
-
if (asignal == SIGQUIT) {
- IOMGR_SoftSig(bozo_ShutdownAndExit, (char *)asignal);
+ IOMGR_SoftSig(bozo_ShutdownAndExit, (void *) asignal);
} else {
- IOMGR_SoftSig(bnode_SoftInt, (char *)asignal);
+ IOMGR_SoftSig(bnode_SoftInt, (void *) asignal);
}
}
}
#endif
-void
-bozo_ShutdownAndExit(int asignal)
+void *
+bozo_ShutdownAndExit(void *param)
{
+ int asignal = (int) param;
int code;
bozo_Log
/* bosserver.c */
void bozo_Log(char *format, ... );
+/* bosoprocs.c */
+void *bozo_ShutdownAndExit(void *arock /* really int asignal */);
+
#endif
#define BOZO_MINSKIP 3600 /* minimum to advance clock */
/* lwp to handle system restarts */
-static int
-BozoDaemon()
+static void *
+BozoDaemon(void *unused)
{
register afs_int32 now;
bnode_ApplyInstance(bdrestart, 0);
}
}
+ return NULL;
}
#ifdef AFS_AIX32_ENV
char *cmdLine;
-int
-cmdDispatch()
+void *
+cmdDispatch(void *unused)
{
#define MAXV 100
char **targv[MAXV]; /*Ptr to parsed argv stuff */
code = cmd_ParseLine(internalCmdLine, targv, &targc, MAXV);
if (code) {
printf("Couldn't parse line: '%s'", afs_error_message(code));
- return (1);
+ return (void *)(1);
}
free(internalCmdLine);
*/
doDispatch(targc, targv, 1);
cmd_FreeArgv(targv);
- return(0);
+ return(void *)(0);
}
-statusWatcher()
+void *
+statusWatcher(void *unused)
{
struct rx_connection *tconn = (struct rc_connection *)0;
statusP curPollPtr = 0;
curPollPtr = 0;
} /*done */
} /*w */
+ return NULL;
}
/* bc_jobNumber
--- /dev/null
+/* Copyright 2000, International Business Machines Corporation and others.
+ * All Rights Reserved.
+ *
+ * This software has been released under the terms of the IBM Public
+ * License. For details, see the LICENSE file in the top-level source
+ * directory or online at http://www.openafs.org/dl/license10.html
+ */
+
+#ifndef _BUCOORD_PROTOTYPES_H
+#define _BUCOORD_PROTOTYPES_H
+
+/* bc_status.c */
+
+extern void *statusWatcher(void *);
+
+#endif
+
* The other half of the dump/restore create process call. In bc_StartDmpRst,
* we allocated a dumpTask entry. Here we do the task and then free the entry.
*/
-bc_DmpRstStart(aindex)
- afs_int32 aindex;
+void *
+bc_DmpRstStart(void *param)
{
+ afs_int32 aindex = (afs_int32) param;
register struct bc_dumpTask *tdump;
register afs_int32 code;
#include <afs/budb.h>
#include "bc.h" /*Backup Coordinator structs and defs */
-
+#include "bucoord_prototypes.h"
int localauth, interact;
char tcell[64];
PROCESS watcherPid;
PROCESS pid; /* LWP process ID */
- extern statusWatcher();
-
/* Initialization */
initialize_CMD_error_table();
#include "globals.h"
#include "afs/audit.h"
+void *dumpWatcher(void *);
/* dump ubik database - interface routines */
* decode the arguments passed via LWP and dump the database.
*/
-setupDbDump(writeFid)
- int writeFid;
+void *
+setupDbDump(void *param)
{
+ int writeFid = (int)param;
afs_int32 code = 0;
code = InitRPC(&dumpSyncPtr->ut, LOCKREAD, 1);
error_exit:
if (dumpSyncPtr->ut)
ubik_EndTrans(dumpSyncPtr->ut);
- return (code);
+ return (void *)(code);
}
PROCESS dumperPid, watcherPid;
int readSize;
afs_int32 code = 0;
- extern dumpWatcher();
if (callPermitted(call) == 0)
ERROR(BUDB_NOTPERMITTED);
* transactions can proceed.
*/
-dumpWatcher()
+void *
+dumpWatcher(void *unused)
{
afs_int32 code;
currentTime = time(0);
LogError(0, "Ready to process requests at %s\n", ctime(¤tTime));
- rx_ServerProc(); /* donate this LWP */
+ rx_ServerProc(NULL); /* donate this LWP */
error_exit:
osi_audit(BUDB_FinishEvent, code, AUD_END);
--- /dev/null
+/* Copyright 2000, International Business Machines Corporation and others.
+ * All Rights Reserved.
+ *
+ * This software has been released under the terms of the IBM Public
+ * License. For details, see the LICENSE file in the top-level source
+ * directory or online at http://www.openafs.org/dl/license10.html
+ */
+
+#ifndef _BUTC_PROTOTYPES_H
+#define _BUTC_PROTOTYPES_H
+
+/* dbentries.c */
+
+extern void *dbWatcher(void *);
+
+/* dump.c */
+
+extern void *Dumper(void *);
+extern void *DeleteDump(void *);
+
+/* lwps.c */
+extern void *Restorer(void *);
+extern void *Labeller(void *);
+
+/* recoverdDb.c */
+
+extern void *ScanDumps(void *);
+
+/* tcudbprocs.c */
+
+extern void *saveDbToTape(void *);
+extern void *restoreDbFromTape(void *);
+extern void *KeepAlive(void *);
+
+#endif
+
#define MAXVOLUMESTOADD 100
int addvolumes = 1;
-void
-dbWatcher()
+void *
+dbWatcher(void *unused)
{
dlqlinkP entryPtr;
struct budb_dumpEntry *dumpPtr;
IOMGR_Sleep(2);
#endif
}
+ return NULL;
}
return (code);
}
-int
-Dumper(struct dumpNode *nodePtr)
+void *
+Dumper(void *param)
{
+ struct dumpNode *nodePtr = (struct dumpNode *)param;
struct dumpRock dparams;
struct butm_tapeInfo tapeInfo;
int pass;
FreeNode(taskId); /* free the dump node */
LeaveDeviceQueue(deviceLatch);
- return (code);
+ return (void *)(code);
}
#define BELLTIME 60 /* 60 seconds before a bell rings */
/* DeleteDump
*
*/
-int
-DeleteDump(struct deleteDumpIf *ptr)
+void *
+DeleteDump(void *param)
{
+ struct deleteDumpIf *ptr = (struct deleteDumpIf *)param;
+
afs_int32 taskId;
afs_int32 rc, code = 0;
afs_uint32 dumpid;
* created as a LWP by the server stub, <newNode> is a pointer to all
* the parameters Restorer needs
*/
-Restorer(newNode)
- struct dumpNode *newNode;
-{
+void *
+Restorer(void *param) {
+ struct dumpNode *newNode = (struct dumpNode *) param;
+
afs_int32 code = 0, tcode;
afs_uint32 taskId;
char *newVolName;
* specified by <label>
*/
-Labeller(labelIfPtr)
- struct labelTapeIf *labelIfPtr;
+void *
+Labeller(void *param)
{
+ struct labelTapeIf *labelIfPtr = (struct labelTapeIf *)param;
+
struct tc_tapeLabel *label = &labelIfPtr->label;
struct butm_tapeLabel newTapeLabel;
*
*/
-int
-ScanDumps(struct scanTapeIf *ptr)
+void *
+ScanDumps(void *param)
{
+ struct scanTapeIf *ptr = (struct scanTapeIf *)param;
+
struct butm_tapeInfo curTapeInfo;
struct tapeScanInfo tapeScanInfo;
afs_uint32 taskId;
free(ptr);
setStatus(taskId, TASK_DONE);
LeaveDeviceQueue(deviceLatch);
- return (code);
+ return (void *)(code);
}
#include "afs/butx.h"
#define XBSA_TCMAIN
#include "butc_xbsa.h"
+#include "butc_prototypes.h"
#define N_SECURITY_OBJECTS 3
#define ERRCODE_RANGE 8 /* from error_table.h */
struct ubik_client *cstruct;
extern void TC_ExecuteRequest();
-extern int dbWatcher();
FILE *logIO, *ErrorlogIO, *centralLogIO, *lastLogIO;
char lFile[AFSDIR_PATH_MAX];
char logFile[256];
#include <afs/tcdata.h>
#include "error_macros.h"
#include "butc_xbsa.h"
-
+#include "butc_prototypes.h"
+
static CopyDumpDesc();
static CopyRestoreDesc();
static CopyTapeSetDesc();
statusP statusPtr = NULL;
afs_int32 code;
- extern int Labeller();
extern statusP createStatusNode();
extern afs_int32 allocTaskId();
afs_int32 code = 0;
extern statusP createStatusNode();
- extern Dumper();
if (callPermitted(rxCallId) == 0)
return (TC_NOTPERMITTED);
PROCESS pid;
#endif
- extern int Restorer();
extern statusP createStatusNode();
if (callPermitted(acid) == 0)
statusP statusPtr;
afs_int32 code = 0;
- extern afs_int32 restoreDbFromTape();
extern statusP createStatusNode();
extern afs_int32 allocTaskId();
afs_int32 code = 0;
struct saveDbIf *ptr;
- extern afs_int32 saveDbToTape();
extern statusP createStatusNode();
extern afs_int32 allocTaskId();
statusP statusPtr;
afs_int32 code = 0;
- extern afs_int32 ScanDumps();
extern afs_int32 allocTaskId();
extern statusP createStatusNode();
PROCESS pid;
#endif
#endif
- extern afs_int32 DeleteDump();
extern statusP createStatusNode();
extern afs_int32 allocTaskId();
static writeDbDump();
static restoreDbEntries();
+void * KeepAlive(void *);
/* CreateDBDump
* create a dump entry for a saved database
*/
extern struct tapeConfig globalTapeConfig;
extern struct udbHandleS udbHandle;
- extern int KeepAlive();
-
blockSize = BUTM_BLKSIZE;
writeBlock = (char *)malloc(BUTM_BLOCKSIZE);
if (!writeBlock)
* dump backup database to tape
*/
-afs_int32
-saveDbToTape(saveDbIfPtr)
- struct saveDbIf *saveDbIfPtr;
+void *
+saveDbToTape(void *param)
{
+ struct saveDbIf *saveDbIfPtr = (struct saveDbIf *)param;
afs_int32 code = 0;
afs_int32 i;
int wroteLabel;
* restore the backup database from tape.
*/
-afs_int32
-restoreDbFromTape(taskId)
- afs_uint32 taskId;
+void *
+restoreDbFromTape(void *param)
{
+ afs_uint32 taskId = (void *)param;
afs_int32 code = 0;
afs_int32 i;
struct butm_tapeInfo tapeInfo;
LeaveDeviceQueue(deviceLatch);
setStatus(taskId, TASK_DONE);
- return (code);
+ return (void *)(code);
}
/* KeepAlive
*
* Use the same udbHandle as writeDbDump so we go to the same server.
*/
-int
-KeepAlive()
+void *
+KeepAlive(void *unused)
{
charListT charList;
afs_int32 code;
* Side Effects:
* As advertised.
*------------------------------------------------------------------------*/
-static void
-fsprobe_LWP()
+static void *
+fsprobe_LWP(void *unused)
{ /*fsprobe_LWP */
static char rn[] = "fsprobe_LWP"; /*Routine name */
fprintf(stderr, "[%s] IOMGR_Select returned code %d\n", rn, code);
} /*Service loop */
free(stats64.ViceStatistics64_val);
+
+ return NULL;
} /*fsprobe_LWP */
/*list all the partitions on <aserver> */
* Implementation of the gator curses window facility.
*
*------------------------------------------------------------------------*/
-#define IGNORE_STDS_H
+
#include <afsconfig.h>
#include <afs/param.h>
#include <string.h>
#include <stdlib.h>
+#include <lwp.h>
+
#include "gtxcurseswin.h" /*Interface definition */
#include "gtxobjects.h"
#include "gtxframe.h"
* directory or online at http://www.openafs.org/dl/license10.html
*/
-#define IGNORE_STDS_H
#include <afsconfig.h>
#include <afs/param.h>
* directory or online at http://www.openafs.org/dl/license10.html
*/
-#define IGNORE_STDS_H
#include <afsconfig.h>
#include <afs/param.h>
/* process input */
-gtx_InputServer(awin)
- register struct gwin *awin;
+void *
+gtx_InputServer(void *param)
{
+ struct gwin *awin = (struct gwin *) param;
+
register int tc;
register int code;
register struct gtx_frame *tframe;
}
ViceLog(0, ("Starting to process AuthServer requests\n"));
- rx_ServerProc(); /* donate this LWP */
+ rx_ServerProc(NULL); /* donate this LWP */
return 0;
}
int fiveminutes = 300;
-static
-FiveMinuteCheckLWP()
+static void *
+FiveMinuteCheckLWP(void *unused)
{
printf("start 5 min check lwp\n");
/* close the log so it can be removed */
ReOpenLog(AFSDIR_SERVER_KALOG_FILEPATH); /* no trunc, just append */
}
+ return NULL;
}
return;
}
-static void
-SocketListener()
+static void *
+SocketListener(void *unused)
{
fd_set rfds;
struct timeval tv;
sock_kerb5 = -1;
}
printf("UDP SocketListener exiting due to error\n");
+
+ return NULL;
}
#if MAIN
#define NSIG 8*sizeof(sigset_t)
#endif
-static int SignalSignals();
+static int SignalSignals(void);
\f
/********************************\
* *
to write it */
/* software 'signals' */
#define NSOFTSIG 4
-static int (*sigProc[NSOFTSIG])();
-static char *sigRock[NSOFTSIG];
+static void *(*sigProc[NSOFTSIG])(void *);
+static void *sigRock[NSOFTSIG];
\f
static struct IoRequest *iorFreeList = 0;
#define FreeRequest(x) ((x)->next = iorFreeList, iorFreeList = (x))
-static struct IoRequest *NewRequest()
+static struct IoRequest *NewRequest(void)
{
struct IoRequest *request;
static fd_set IOMGR_readfds, IOMGR_writefds, IOMGR_exceptfds;
static int IOMGR_nfds = 0;
-static int IOMGR(void *dummy)
+static void *IOMGR(void *dummy)
{
for (;;) {
int code;
}
LWP_DispatchProcess();
}
- return -1; /* keeps compilers happy. */
+ return (void *)-1; /* keeps compilers happy. */
}
\f
/************************\
* signalling routines, above). *
* *
\*****************************************************/
-static void SigHandler (signo)
- int signo;
+static void SigHandler (int signo)
{
if (badsig(signo) || (sigsHandled & mysigmask(signo)) == 0)
return; /* can't happen. */
{
bool gotone = FALSE;
register int i;
- register int (*p)();
+ register void *(*p)(void *);
afs_int32 stackSize;
anySigsDelivered = FALSE;
stackSize = (AFS_LWP_MINSTACKSIZE < lwp_MaxStackSeen? lwp_MaxStackSeen : AFS_LWP_MINSTACKSIZE);
for (i=0; i < NSOFTSIG; i++) {
PROCESS pid;
- if (p=sigProc[i]) /* This yields!!! */
+ if ((p=sigProc[i])) /* This yields!!! */
LWP_CreateProcess2(p, stackSize, LWP_NORMAL_PRIORITY,
- (void *) sigRock[i], "SignalHandler", &pid);
+ sigRock[i], "SignalHandler", &pid);
sigProc[i] = 0;
}
/* Keep IOMGR process id */
static PROCESS IOMGR_Id = NULL;
-int IOMGR_SoftSig(aproc, arock)
-int (*aproc)();
-char *arock; {
+int IOMGR_SoftSig(void *(*aproc)(void *), void *arock)
+{
register int i;
for (i=0;i<NSOFTSIG;i++) {
if (sigProc[i] == 0) {
int IOMGR_Initialize(void)
{
- extern int TM_Init();
PROCESS pid;
/* If lready initialized, just return */
"IO MANAGER", &IOMGR_Id);
}
-int IOMGR_Finalize()
+int IOMGR_Finalize(void)
{
int status;
return 0;
}
-int IOMGR_Select(fds, readfds, writefds, exceptfds, timeout)
- int fds;
- fd_set *readfds, *writefds, *exceptfds;
- struct timeval *timeout;
+int IOMGR_Select(int fds, fd_set *readfds, fd_set *writefds,
+ fd_set *exceptfds, struct timeval *timeout)
{
register struct IoRequest *request;
int result;
#ifdef DEBUG
if (lwp_debug != 0) puts("[Polling SELECT]");
#endif /* DEBUG */
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_NT40_ENV)
again:
+#endif
code = select(fds, readfds, writefds, exceptfds, timeout);
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_AIX32_ENV)
/*
/* release a write lock and sleep on an address, atomically */
void
-LWP_WaitProcessR(addr, alock)
- register char *addr;
- register struct Lock *alock;
+LWP_WaitProcessR(register void *addr, register struct Lock *alock)
{
ReleaseReadLock(alock);
LWP_WaitProcess(addr);
/* release a write lock and sleep on an address, atomically */
void
-LWP_WaitProcessW(addr, alock)
- register char *addr;
- register struct Lock *alock;
+LWP_WaitProcessW(register void *addr, register struct Lock *alock)
{
ReleaseWriteLock(alock);
LWP_WaitProcess(addr);
/* release a write lock and sleep on an address, atomically */
void
-LWP_WaitProcessS(addr, alock)
- register char *addr;
- register struct Lock *alock;
+LWP_WaitProcessS(register void *addr, register struct Lock *alock)
{
ReleaseSharedLock(alock);
LWP_WaitProcess(addr);
extern void Afs_Lock_Obtain(struct Lock *lock, int how);
extern void Afs_Lock_ReleaseR(struct Lock *lock);
extern void Afs_Lock_ReleaseW(struct Lock *lock);
+extern void Afs_Lock_WakeupR(struct Lock *lock);
void Lock_Init(struct Lock *lock);
void Lock_Destroy(struct Lock *lock);
} while (0)
#endif
\f
-static int Dispatcher();
-static int Create_Process_Part2();
-static int Exit_LWP();
-static afs_int32 Initialize_Stack();
-static int Stack_Used();
-char (*RC_to_ASCII());
-
-static void Abort_LWP();
-static void Overflow_Complain();
-static void Initialize_PCB();
-static void Dispose_of_Dead_PCB();
-static void Free_PCB();
-static int Internal_Signal();
-static purge_dead_pcbs();
+static void *Dispatcher(void *);
+static void *Create_Process_Part2(void *);
+static void *Exit_LWP(void *);
+static afs_int32 Initialize_Stack(char *stackptr, int stacksize);
+static int Stack_Used(register char *stackptr, int stacksize);
+
+static void Abort_LWP(char *msg);
+static void Overflow_Complain(void);
+static void Initialize_PCB(PROCESS temp, int priority, char *stack,
+ int stacksize, void *(*ep)(void *), void *parm,
+ char *name);
+static void Dispose_of_Dead_PCB(PROCESS cur);
+static void Free_PCB(PROCESS pid);
+static int Internal_Signal(void *event);
+static int purge_dead_pcbs(void);
+static int LWP_MwaitProcess(int wcount, void *evlist[]);
+
#define MAX_PRIORITIES (LWP_MAX_PRIORITY+1)
PROCESS head;
int count;
} runnable[MAX_PRIORITIES], blocked, qwaiting;
-/* Invariant for runnable queues: The head of each queue points to the currently running process if it is in that queue, or it points to the next process in that queue that should run. */
+/* Invariant for runnable queues: The head of each queue points to the
+ * currently running process if it is in that queue, or it points to the
+ * next process in that queue that should run. */
/* Offset of stack field within pcb -- used by stack checking stuff */
int stack_offset;
#endif
int
-LWP_CreateProcess(int (*ep) (), int stacksize, int priority, void *parm,
+LWP_CreateProcess(void *(*ep) (void *), int stacksize, int priority, void *parm,
char *name, PROCESS * pid)
{
PROCESS temp, temp2;
#ifdef AFS_AIX32_ENV
int
-LWP_CreateProcess2(int (*ep) (), int stacksize, int priority, void *parm,
+LWP_CreateProcess2(void *(*ep) (void *), int stacksize, int priority, void *parm,
char *name, PROCESS * pid)
{
PROCESS temp, temp2;
}
int
-LWP_INTERNALSIGNAL(char *event, int yield)
+LWP_INTERNALSIGNAL(void *event, int yield)
{ /* signal the occurence of an event */
Debug(2, ("Entered LWP_SignalProcess"));
if (lwp_init) {
}
int
-LWP_WaitProcess(char *event)
+LWP_WaitProcess(void *event)
{ /* wait on a single event */
- char *tempev[2];
+ void *tempev[2];
Debug(2, ("Entered Wait_Process"));
if (event == NULL)
}
int
-LWP_MwaitProcess(int wcount, char *evlist[])
+LWP_MwaitProcess(int wcount, void *evlist[])
{ /* wait on m of n events */
register int ecount, i;
if (ecount > lwp_cpptr->eventlistsize) {
lwp_cpptr->eventlist =
- (char **)realloc(lwp_cpptr->eventlist,
- ecount * sizeof(char *));
+ (void **)realloc(lwp_cpptr->eventlist,
+ ecount * sizeof(void *));
lwp_cpptr->eventlistsize = ecount;
}
for (i = 0; i < ecount; i++)
Dump_Processes();
#endif
if (LWPANCHOR.outersp == NULL)
- Exit_LWP();
+ Exit_LWP(NULL);
else
savecontext(Exit_LWP, &tempcontext, LWPANCHOR.outersp);
return;
}
-static int
-Create_Process_Part2(void)
+static void *
+Create_Process_Part2(void *unused)
{ /* creates a context for the new process */
PROCESS temp;
int LWP_TraceProcesses = 0;
-static int
-Dispatcher(void)
+static void *
+Dispatcher(void *unused)
{ /* Lightweight process dispatcher */
register int i;
#ifdef DEBUG
printf("stackcheck = %u: stack = %u \n", lwp_cpptr->stackcheck,
*(int *)lwp_cpptr->stack);
printf("topstack = 0x%x: stackptr = 0x%x: stacksize = 0x%x\n",
- lwp_cpptr->context.topstack, lwp_cpptr->stack,
+ (unsigned int)lwp_cpptr->context.topstack,
+ (unsigned int)lwp_cpptr->stack,
lwp_cpptr->stacksize);
switch (lwp_overflowAction) {
*/
}
-static int
-Exit_LWP(void)
+static void *
+Exit_LWP(void *unused)
{
abort();
}
static void
Initialize_PCB(PROCESS temp, int priority, char *stack, int stacksize,
- int (*ep) (), void *parm, char *name)
+ void *(*ep) (void *), void *parm, char *name)
{
register int i = 0;
i++;
temp->name[31] = '\0';
temp->status = READY;
- temp->eventlist = (char **)malloc(EVINITSIZE * sizeof(char *));
+ temp->eventlist = (void **)malloc(EVINITSIZE * sizeof(void *));
temp->eventlistsize = EVINITSIZE;
temp->eventcnt = 0;
temp->wakevent = 0;
}
static int
-Internal_Signal(register char *event)
+Internal_Signal(register void *event)
{
int rc = LWP_ENOWAIT;
register int i;
#ifdef AFS_SUN5_ENV
int
-LWP_NoYieldSignal(char *event)
+LWP_NoYieldSignal(void *event)
{
return (LWP_INTERNALSIGNAL(event, 0));
}
int
-LWP_SignalProcess(char *event)
+LWP_SignalProcess(void *event)
{
return (LWP_INTERNALSIGNAL(event, 1));
}
typedef struct event {
struct event *next; /* next in hash chain */
- char *event; /* lwp event: an address */
+ void *event; /* lwp event: an address */
int refcount; /* Is it in use? */
pthread_cond_t cond; /* Currently associated condition variable */
int seq; /* Sequence number: this is incremented
/* Get and initialize event structure corresponding to lwp event (i.e. address) */
static event_t *
-getevent(char *event)
+getevent(void *event)
{
event_t *evp, *newp;
int hashcode;
#define relevent(evp) ((evp)->refcount--)
int
-LWP_WaitProcess(char *event)
+LWP_WaitProcess(void *event)
{ /* wait on a single event */
struct event *ev;
int seq;
}
int
-LWP_NoYieldSignal(char *event)
+LWP_NoYieldSignal(void *event)
{
struct event *ev;
debugf(("%s: no yield signal (%x)\n", lwp_process_string(), event));
}
int
-LWP_SignalProcess(char *event)
+LWP_SignalProcess(void *event)
{
struct event *ev;
debugf(("%s: signal process (%x)\n", lwp_process_string(), event));
char blockflag; /* if (blockflag), process blocked */
char eventlistsize; /* size of eventlist array */
char padding; /* force 32-bit alignment */
- char **eventlist; /* ptr to array of eventids */
+ void **eventlist; /* ptr to array of eventids */
int eventcnt; /* no. of events currently in eventlist array */
int wakevent; /* index of eventid causing wakeup */
int waitcnt; /* min number of events awaited */
char *stack; /* ptr to process stack */
int stacksize; /* size of stack */
int stackcheck; /* first word of stack for overflow checking */
- int (*ep) (); /* initial entry point */
+ void *(*ep)(void *); /* initial entry point */
char *parm; /* initial parm for process */
struct lwp_context
context; /* saved context for next dispatch */
extern int IOMGR_Cancel(PROCESS pid);
extern int IOMGR_Initialize(void);
extern void IOMGR_FreeFDSet(fd_set * fds);
-extern int IOMGR_SoftSig(int (*aproc) (), char *arock);
+extern int IOMGR_SoftSig(void *(*aproc) (void *), void *arock);
/* fasttime.c */
extern int LWP_QSignal(PROCESS pid);
#else
extern int LWP_CurrentProcess(PROCESS * pid);
-extern int LWP_INTERNALSIGNAL(char *event, int yield);
+extern int LWP_INTERNALSIGNAL(void *event, int yield);
extern int LWP_InitializeProcessSupport(int priority, PROCESS * pid);
-extern int LWP_CreateProcess(int (*ep) (), int stacksize, int priority,
+extern int LWP_CreateProcess(void *(*ep)(void *), int stacksize, int priority,
void *parm, char *name, PROCESS * pid);
extern int LWP_DestroyProcess(PROCESS pid);
-extern int LWP_WaitProcess(char *event);
+extern int LWP_DispatchProcess(void);
+extern int LWP_WaitProcess(void *event);
extern PROCESS LWP_ThreadId(void);
+extern int LWP_QWait(void);
+extern int LWP_QSignal(register PROCESS pid);
#endif
+extern afs_int32 savecontext(void *(*ep)(void *),
+ struct lwp_context *savearea, char *sp);
+extern void returnto(struct lwp_context *savearea);
+
#ifdef AFS_LINUX24_ENV
/* max time we are allowed to spend in a select call on Linux to avoid
lost signal issues */
}
int
-PRE_EndPreempt()
+PRE_EndPreempt(void)
{
return LWP_SUCCESS;
}
#if defined(USE_UCONTEXT) && defined(HAVE_UCONTEXT_H)
afs_int32
-savecontext(char (*ep) (), struct lwp_context *savearea, char *newsp)
+savecontext(void (*ep) (void *dummy), struct lwp_context *savearea, char *newsp)
{
#if defined(AFS_LINUX20_ENV)
/* getcontext does not export stack info */
}
void
-returnto(savearea)
- struct lwp_context *savearea;
+returnto(struct lwp_context *savearea)
{
PRE_Block = 0;
afs_int32
savecontext(ep, savearea, sp)
- char (*ep) ();
+ void (*ep) ();
struct lwp_context *savearea;
char *sp;
{
return 0;
}
-afs_int32
+void
returnto(struct lwp_context * savearea)
{
#if defined(DEBUG)
#endif
PRE_Block = 0;
longjmp(savearea->setjmp_buffer, 2);
- return 0;
+ return;
}
#endif
#ifndef _TIMER_IMPL_
#define Tm_Insert(list, elem) openafs_insque(list, elem)
#define TM_Remove(list, elem) openafs_remque(elem)
-extern int TM_Rescan();
-void TM_Insert();
-extern struct TM_Elem *TM_GetExpired();
-extern struct TM_Elem *TM_GetEarliest();
+extern int TM_Rescan(struct TM_Elem *tlist);
+void TM_Insert(struct TM_Elem *tlistPtr, struct TM_Elem *elem);
+extern struct TM_Elem *TM_GetExpired(struct TM_Elem *tlist);
+extern struct TM_Elem *TM_GetEarliest(struct TM_Elem *tlist);
#endif
-extern int TM_Final();
+extern int TM_Init(register struct TM_Elem **list);
+extern int TM_Final(register struct TM_Elem **list);
#define FOR_ALL_ELTS(var, list, body)\
{\
/* This is the server process request loop. The server process loop
* becomes a listener thread when rxi_ServerProc returns, and stays
* listener thread until rxi_ListenerProc returns. */
-void
-rx_ServerProc(void)
+void *
+rx_ServerProc(void *unused)
{
osi_socket sock;
int threadID;
(*registerProgram) (pid, name);
#endif /* KERNEL */
#endif /* AFS_NT40_ENV */
- rx_ServerProc(); /* Never returns */
+ rx_ServerProc(NULL); /* Never returns */
}
#ifdef RX_ENABLE_TSFPQ
/* no use leaving packets around in this thread's local queue if
#ifndef UKERNEL
/* This is the server process request loop. Kernel server
* processes never become listener threads */
-void
-rx_ServerProc(void)
+void *
+rx_ServerProc(void *unused)
{
int threadID;
}
PROCESS rx_listenerPid = 0; /* LWP process id of socket listener process */
-static int rx_ListenerProc(void *dummy);
+static void* rx_ListenerProc(void *dummy);
/*
* Delay the current thread the specified number of seconds.
}
void
-rxi_StartServerProc(void (*proc) (void), int stacksize)
+rxi_StartServerProc(void *(*proc) (void *), int stacksize)
{
PROCESS scratchPid;
static int number = 0;
char name[32];
sprintf(name, "srv_%d", ++number);
- LWP_CreateProcess((int (*)(void *))proc, stacksize, RX_PROCESS_PRIORITY, (void *)0,
+ LWP_CreateProcess(proc, stacksize, RX_PROCESS_PRIORITY, NULL,
"rx_ServerProc", &scratchPid);
if (registerProgram)
(*registerProgram) (scratchPid, name);
/* This is the listener process request loop. The listener process loop
* becomes a server thread when rxi_ListenerProc returns, and stays
* server thread until rxi_ServerProc returns. */
-static int
+static void *
rx_ListenerProc(void *dummy)
{
int threadID;
/* assert(sock != OSI_NULLSOCKET); */
}
/* not reached */
+ return NULL;
}
/* This is the server process request loop. The server process loop
* becomes a listener thread when rxi_ServerProc returns, and stays
* listener thread until rxi_ListenerProc returns. */
-void
-rx_ServerProc(void)
+void *
+rx_ServerProc(void * unused)
{
osi_socket sock;
int threadID;
/* assert(newcall != NULL); */
}
/* not reached */
+ return NULL;
}
/*
extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host,
int *port);
#ifdef UKERNEL
-extern void rx_ServerProc(void);
+extern void *rx_ServerProc(void *);
#endif
extern void osi_AssertFailK(const char *expr, const char *file, int line);
extern void rxk_ListenerProc(void);
/* rx_lwp.c */
-extern void rx_ServerProc(void);
extern void rxi_Sleep(void *addr);
extern void rxi_Delay(int seconds);
extern void rxi_InitializeThreadSupport(void);
extern void rxi_ReScheduleEvents(void);
#endif
extern void rxi_InitializeThreadSupport(void);
-extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
+extern void rxi_StartServerProc(void *(*proc) (void *), int stacksize);
extern void rxi_StartListener(void);
-extern void rx_ServerProc(void);
+extern void *rx_ServerProc(void *);
extern int rxi_Listen(osi_socket sock);
extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
/* rx_pthread.c */
extern void rxi_Delay(int sec);
extern void rxi_InitializeThreadSupport(void);
-extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
+extern void rxi_StartServerProc(void *(*proc) (void *), int stacksize);
#ifndef rxi_ReScheduleEvents
extern void rxi_ReScheduleEvents(void);
#endif
-extern void rx_ServerProc(void);
+extern void *rx_ServerProc(void *);
extern void rxi_StartListener(void);
extern int rxi_Listen(osi_socket sock);
extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
* Start an Rx server process.
*/
void
-rxi_StartServerProc(void (*proc) (void), int stacksize)
+rxi_StartServerProc(void *(*proc) (void *), int stacksize)
{
pthread_t thread;
pthread_attr_t tattr;
/* This is the server process request loop. The server process loop
* becomes a listener thread when rxi_ServerProc returns, and stays
* listener thread until rxi_ListenerProc returns. */
-void
-rx_ServerProc(void)
+void *
+rx_ServerProc(void * dummy)
{
osi_socket sock;
int threadID;
* we're sync site or we want to be the sync site. It runs in its very own light-weight
* process.
*/
-ubeacon_Interact()
+void *
+ubeacon_Interact(void *dummy)
{
register afs_int32 code;
struct timeval tt;
* requests. However, the recovery module still has one more task:
* propagating the dbase out to everyone who is up in the network.
*/
-int
-urecovery_Interact(void)
+void *
+urecovery_Interact(void *dummy)
{
afs_int32 code, tcode;
struct ubik_server *bestServer = NULL;
struct rx_service *tservice;
extern int VOTE_ExecuteRequest(), DISK_ExecuteRequest();
- extern void rx_ServerProc();
extern int rx_stackSize;
initialize_U_error_table();
extern int urecovery_AbortAll(struct ubik_dbase *adbase);
extern int urecovery_CheckTid(register struct ubik_tid *atid);
extern int urecovery_Initialize(register struct ubik_dbase *adbase);
-extern int urecovery_Interact(void);
+extern void *urecovery_Interact(void *);
extern int DoProbe(struct ubik_server *server);
-extern int ubeacon_Interact();
+extern void *ubeacon_Interact(void *);
extern int sdisk_Interact();
extern int uvote_Interact();
extern int DISK_Abort();
#include <sys/stat.h>
#include "afsutil.h"
#include "fileutil.h"
+#include <lwp.h>
#if defined(AFS_PTHREAD_ENV)
#include <assert.h>
#include <pthread.h>
va_end(args);
} /*FSLog */
-static int
-DebugOn(int loglevel)
+static void*
+DebugOn(void *param)
{
+ int loglevel = (int)param;
if (loglevel == 0) {
ViceLog(0, ("Reset Debug levels to 0\n"));
} else {
void
SetDebug_Signal(int signo)
{
-/* extern int IOMGR_SoftSig();*/
-
if (LogLevel > 0) {
LogLevel *= 5;
}
printLocks = 2;
#if defined(AFS_PTHREAD_ENV)
- DebugOn(LogLevel);
+ DebugOn((void *) LogLevel);
#else /* AFS_PTHREAD_ENV */
- IOMGR_SoftSig(DebugOn, LogLevel);
+ IOMGR_SoftSig(DebugOn, (void *) LogLevel);
#endif /* AFS_PTHREAD_ENV */
(void)signal(signo, SetDebug_Signal); /* on some platforms, this
if (printLocks > 0)
--printLocks;
#if defined(AFS_PTHREAD_ENV)
- DebugOn(LogLevel);
+ DebugOn((void *) LogLevel);
#else /* AFS_PTHREAD_ENV */
- IOMGR_SoftSig(DebugOn, LogLevel);
+ IOMGR_SoftSig(DebugOn, (void *) LogLevel);
#endif /* AFS_PTHREAD_ENV */
(void)signal(signo, ResetDebug_Signal); /* on some platforms,
struct AFSCBFids *afidp);
extern int DumpCallBackState(void);
extern int PrintCallBackStats(void);
-extern int ShutDown(void);
+extern void *ShutDown(void *);
extern void ShutDownAndCore(int dopanic);
extern struct host *h_Alloc(register struct rx_connection *r_con);
extern int LogLevel, etext;
extern afs_int32 BlocksSpare, PctSpare;
-int ShutDown(void);
+void *ShutDown(void *);
static void ClearXStatValues(), NewParms(), PrintCounters();
static void ResetCheckDescriptors(void), ResetCheckSignal(void);
-static int CheckSignal(void);
+static void *CheckSignal(void *);
extern int GetKeysFromToken();
extern int RXAFS_ExecuteRequest();
extern int RXSTATS_ExecuteRequest();
*/
/* DEBUG HACK */
-static int
-CheckDescriptors()
+static void *
+CheckDescriptors(void *unused)
{
#ifndef AFS_NT40_ENV
struct afs_stat status;
}
fflush(stdout);
ResetCheckDescriptors();
- return 0;
#endif
+ return 0;
} /*CheckDescriptors */
void
CheckSignal_Signal(x)
{
- CheckSignal();
+ CheckSignal(NULL);
}
void
ShutDown_Signal(x)
{
- ShutDown();
+ ShutDown(NULL);
}
void
CheckDescriptors_Signal(x)
{
- CheckDescriptors();
+ CheckDescriptors(NULL);
}
#else /* AFS_PTHREAD_ENV */
void
}
/* This LWP does things roughly every 5 minutes */
-static void
-FiveMinuteCheckLWP()
+static void *
+FiveMinuteCheckLWP(void *unused)
{
static int msg = 0;
char tbuffer[32];
FS_UNLOCK;
FS_STATE_UNLOCK;
#endif
+ return NULL;
} /*FiveMinuteCheckLWP */
* it probes the workstations
*/
-static void
-HostCheckLWP()
+static void *
+HostCheckLWP(void *unused)
{
ViceLog(1, ("Starting Host check process\n"));
setThreadId("HostCheckLWP");
FS_UNLOCK;
FS_STATE_UNLOCK;
#endif
+ return NULL;
} /*HostCheckLWP */
/* This LWP does fsync checks every 5 minutes: it should not be used for
* other 5 minute activities because it may be delayed by timeouts when
* it probes the workstations
*/
-static void
-FsyncCheckLWP()
+static void *
+FsyncCheckLWP(void *unused)
{
afs_int32 code;
#ifdef AFS_PTHREAD_ENV
FS_UNLOCK;
FS_STATE_UNLOCK;
#endif /* AFS_DEMAND_ATTACH_FS */
+ return NULL;
}
/*------------------------------------------------------------------------
-static int
-CheckSignal()
+static void *
+CheckSignal(void *unused)
{
if (FS_registered > 0) {
/*
exit(0);
}
-int
-ShutDown(void)
+void *
+ShutDown(void *unused)
{ /* backward compatibility */
ShutDownAndCore(DONTPANIC);
return 0;
assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
assert(pthread_create
- (&serverPid, &tattr, (void *)FiveMinuteCheckLWP,
+ (&serverPid, &tattr, FiveMinuteCheckLWP,
&fiveminutes) == 0);
assert(pthread_create
- (&serverPid, &tattr, (void *)HostCheckLWP, &fiveminutes) == 0);
+ (&serverPid, &tattr, HostCheckLWP, &fiveminutes) == 0);
assert(pthread_create
- (&serverPid, &tattr, (void *)FsyncCheckLWP, &fiveminutes) == 0);
+ (&serverPid, &tattr, FsyncCheckLWP, &fiveminutes) == 0);
#else /* AFS_PTHREAD_ENV */
ViceLog(5, ("Starting LWP\n"));
assert(LWP_CreateProcess
extern int afsconf_CheckAuth();
extern int afsconf_ServerAuth();
-static CheckSignal();
+static void *CheckSignal(void*);
int LogLevel = 0;
int smallMem = 0;
int rxJumbograms = 1; /* default is to send and receive jumbo grams */
IOMGR_SoftSig(CheckSignal, 0);
}
-static
-CheckSignal()
+static void *
+CheckSignal(void *unused)
{
register int i, errorcode;
struct ubik_trans *trans;
for (i = 0; i < HASHSIZE; i++) {
HashIdDump(trans, i);
}
- return (ubik_EndTrans(trans));
+ return ((void *)ubik_EndTrans(trans));
} /*CheckSignal */
}
/* background daemon for timing out transactions */
-static void
-BKGLoop()
+static void*
+BKGLoop(void *unused)
{
struct timeval tv;
int loop = 0;
ReOpenLog(AFSDIR_SERVER_VOLSERLOG_FILEPATH);
}
}
+
+ return NULL;
}
/* Background daemon for sleeping so the volserver does not become I/O bound */
afs_int32 TTsleep, TTrun;
-static void
-BKGSleep()
+static void *
+BKGSleep(void *unused)
{
struct volser_trans *tt;
VTRANS_UNLOCK;
}
}
+ return NULL;
}
#ifndef AFS_NT40_ENV
* Side Effects:
* As advertised.
*------------------------------------------------------------------------*/
-static void
-xstat_cm_LWP()
+static void *
+xstat_cm_LWP(void *unused)
{
static char rn[] = "xstat_cm_LWP"; /*Routine name */
register afs_int32 code; /*Results of calls */
code);
} /*Continuous execution */
} /*Service loop */
+ return NULL;
}
* Nothing interesting.
*------------------------------------------------------------------------*/
-static void
-xstat_fs_LWP()
+static void *
+xstat_fs_LWP(void *unused)
{
static char rn[] = "xstat_fs_LWP"; /*Routine name */
register afs_int32 code; /*Results of calls */
code);
} /*Continuous execution */
} /*Service loop */
+ return NULL;
}
/*------------------------------------------------------------------------
git://git.openafs.org / openafs.git / commitdiff