#ifdef AFS_SGI62_ENV
#include "../h/hashing.h"
#endif
-#if !defined(AFS_HPUX110_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN60_ENV)
#include "netinet/in_var.h"
#endif
#endif /* !defined(UKERNEL) */
static int afs_Go_Done = 0;
extern struct interfaceAddr afs_cb_interface;
static int afs_RX_Running = 0;
+static int afs_InitSetup_done = 0;
static int
Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval);
extern void afs_InitStats();
int code;
+ if (afs_InitSetup_done)
+ return;
+
#ifndef AFS_NOSTATS
/*
* Set up all the AFS statistics variables. This should be done
/* resource init creates the services */
afs_ResourceInit(preallocs);
+ afs_InitSetup_done = 1;
+ afs_osi_Wakeup(&afs_InitSetup_done);
+
return code;
}
+/* leaving as is, probably will barf if we add prototypes here since it's likely being called
+with partial list */
afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
long parm, parm2, parm3, parm4, parm5, parm6;
{
afs_int32 code = 0;
+#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+ size_t bufferSize;
+#else /* AFS_SGI61_ENV */
+ u_int bufferSize;
+#endif /* AFS_SGI61_ENV */
AFS_STATCNT(afs_syscall_call);
#ifdef AFS_SUN5_ENV
if (!afs_suser() && (parm != AFSOP_GETMTU)
&& (parm != AFSOP_GETMASK)) {
/* only root can run this code */
-#if !defined(AFS_SGI_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(EACCES);
return(EACCES);
#else
#endif
}
#endif
- else if (parm == AFSOP_START_AFS) {
- /* afs daemon */
+ else if (parm == AFSOP_BASIC_INIT) {
afs_int32 temp;
- if (AFS_Running) goto out;
- AFS_Running = 1;
- while (afs_initState < AFSOP_START_AFS)
- afs_osi_Sleep(&afs_initState);
+ while (!afs_InitSetup_done)
+ afs_osi_Sleep(&afs_InitSetup_done);
#if defined(AFS_SUN_ENV) || defined(AFS_SGI_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
temp = AFS_MINBUFFERS; /* Should fix this soon */
#else
- temp = ((afs_bufferpages * NBPG)>>11); /* number of 2k buffers we could get from all of the buffer space */
+ /* number of 2k buffers we could get from all of the buffer space */
+ temp = ((afs_bufferpages * NBPG)>>11);
temp = temp>>2; /* don't take more than 25% (our magic parameter) */
- if (temp < AFS_MINBUFFERS) temp = AFS_MINBUFFERS; /* although we really should have this many */
+ if (temp < AFS_MINBUFFERS)
+ temp = AFS_MINBUFFERS; /* though we really should have this many */
#endif
DInit(temp);
+ afs_rootFid.Fid.Volume = 0;
+ code = 0;
+ }
+ else if (parm == AFSOP_START_AFS) {
+ /* afs daemon */
+ if (AFS_Running) goto out;
+ AFS_Running = 1;
+ while (afs_initState < AFSOP_START_AFS)
+ afs_osi_Sleep(&afs_initState);
+
afs_initState = AFSOP_START_BKG;
afs_osi_Wakeup(&afs_initState);
afs_osi_Invisible();
home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
struct afsop_cell tcell;
- while (afs_initState < AFSOP_START_BKG) afs_osi_Sleep(&afs_initState);
AFS_COPYIN((char *)parm2, (char *)tcell.hosts, sizeof(tcell.hosts), code);
if (!code) {
if (parm4 > sizeof(tcell.cellName))
AFS_COPYIN((char *)parm3, tcell.cellName, parm4, code);
if (!code)
afs_NewCell(tcell.cellName, tcell.hosts, parm5,
- (char *)0, (u_short)0, (u_short)0, (int)0);
+ NULL, 0, 0, 0);
}
}
} else if (parm == AFSOP_ADDCELL2) {
struct afsop_cell tcell;
char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ), *lcnamep = 0;
char *tbuffer1 = osi_AllocSmallSpace(AFS_SMALLOCSIZ), *cnamep = 0;
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- size_t bufferSize;
-#else /* AFS_SGI61_ENV */
- u_int bufferSize;
-#endif /* AFS_SGI61_ENV */
int cflags = parm4;
/* wait for basic init */
}
}
if (!code)
- afs_NewCell(tbuffer1, tcell.hosts, cflags,
- lcnamep, (u_short)0, (u_short)0, (int)0);
+ code = afs_NewCell(tbuffer1, tcell.hosts, cflags,
+ lcnamep, 0, 0, 0);
}
}
osi_FreeSmallSpace(tbuffer);
* parm2 is the alias name
* parm3 is the real cell name
*/
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- size_t bufferSize;
-#else /* AFS_SGI61_ENV */
- u_int bufferSize;
-#endif /* AFS_SGI61_ENV */
char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
AFS_COPYINSTR((char *)parm2, aliasName, AFS_SMALLOCSIZ, &bufferSize, code);
if (!code) AFS_COPYINSTR((char *)parm3, cellName, AFS_SMALLOCSIZ, &bufferSize, code);
- if (!code) afs_NewCell(aliasName, /* new entry name */
- 0, /* host list */
- CAlias, /* flags */
- (char *) 0, /* linked cell */
- 0, 0, /* fs & vl ports */
- 0, /* timeout */
- cellName); /* real cell name */
-
+ if (!code) afs_NewCellAlias(aliasName, cellName);
osi_FreeSmallSpace(aliasName);
osi_FreeSmallSpace(cellName);
}
+ else if (parm == AFSOP_SET_THISCELL) {
+ /*
+ * Call arguments:
+ * parm2 is the primary cell name
+ */
+ char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
+
+ AFS_COPYINSTR((char *) parm2, cell, AFS_SMALLOCSIZ, &bufferSize, code);
+ if (!code)
+ afs_SetPrimaryCell(cell);
+ osi_FreeSmallSpace(cell);
+ }
else if (parm == AFSOP_CACHEINIT) {
struct afs_cacheParams cparms;
if (afs_CacheInit_Done) goto out;
- /* wait for basic init */
- while (afs_initState < AFSOP_START_BKG) afs_osi_Sleep(&afs_initState);
AFS_COPYIN((char *)parm2, (caddr_t) &cparms, sizeof(cparms), code);
if (code) {
-#if defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined (AFS_SGI64_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- goto out;
-#else
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(code);
code = -1;
- goto out;
#endif
+ goto out;
}
afs_CacheInit_Done = 1;
{
#ifdef AFS_SGI62_ENV
ainode = (ainode << 32) | (parm3 & 0xffffffff);
#endif
- code = afs_InitCacheFile((char *) 0, ainode);
+ code = afs_InitCacheFile(NULL, ainode);
}
else if (parm == AFSOP_ROOTVOLUME) {
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- size_t bufferSize;
-#else /* AFS_SGI61_ENV */
- u_int bufferSize;
-#endif /* AFS_SGI61_ENV */
-
/* wait for basic init */
while (afs_initState < AFSOP_START_BKG) afs_osi_Sleep(&afs_initState);
}
else code = 0;
}
- else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO ||
- parm == AFSOP_VOLUMEINFO || parm == AFSOP_AFSLOG) {
+ else if (parm == AFSOP_CACHEFILE ||
+ parm == AFSOP_CACHEINFO ||
+ parm == AFSOP_VOLUMEINFO ||
+ parm == AFSOP_AFSLOG ||
+ parm == AFSOP_CELLINFO) {
char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- size_t bufferSize;
-#else /* AFS_SGI61_ENV */
- u_int bufferSize;
-#endif /* AFS_SGI61_ENV */
- /* wait for basic init */
- while (afs_initState < AFSOP_START_BKG) afs_osi_Sleep(&afs_initState);
code = 0;
- AFS_COPYINSTR((char *)parm2, tbuffer, AFS_SMALLOCSIZ, &bufferSize, code);
+ AFS_COPYINSTR((char *) parm2, tbuffer, AFS_SMALLOCSIZ,
+ &bufferSize, code);
if (code) {
osi_FreeSmallSpace(tbuffer);
goto out;
}
if (!code) {
- tbuffer[AFS_SMALLOCSIZ-1] = 0; /* null-terminate the name */
- /* we now have the cache dir copied in. Call the cache init routines */
- if (parm == AFSOP_CACHEFILE) code = afs_InitCacheFile(tbuffer, 0);
- else if (parm == AFSOP_CACHEINFO) code = afs_InitCacheInfo(tbuffer);
- else if (parm == AFSOP_VOLUMEINFO) code = afs_InitVolumeInfo(tbuffer);
+ tbuffer[AFS_SMALLOCSIZ-1] = '\0'; /* null-terminate the name */
+ /* We have the cache dir copied in. Call the cache init routine */
+ if (parm == AFSOP_CACHEFILE)
+ code = afs_InitCacheFile(tbuffer, 0);
+ else if (parm == AFSOP_CACHEINFO)
+ code = afs_InitCacheInfo(tbuffer);
+ else if (parm == AFSOP_VOLUMEINFO)
+ code = afs_InitVolumeInfo(tbuffer);
+ else if (parm == AFSOP_CELLINFO)
+ code = afs_InitCellInfo(tbuffer);
}
osi_FreeSmallSpace(tbuffer);
}
if (afs_globalVFS != 0) {
afs_warn("AFS isn't unmounted yet! Call aborted\n");
code = EACCES;
- }
- afs_shutdown();
+ } else
+ afs_shutdown();
}
#if ! defined(AFS_HPUX90_ENV) || defined(AFS_HPUX100_ENV)
afs_vfs_mount(parm2, parm3, parm4, parm5);
#endif /* AFS_HPUX100_ENV */
#else /* defined(AFS_HPUX_ENV) */
-#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- code = EINVAL;
-#else
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(EINVAL);
+#else
+ code = EINVAL;
#endif
#endif /* defined(AFS_HPUX_ENV) */
}
}
#else /* AFS_USERSPACE_IP_ADDR */
struct ifnet *tifnp;
+#ifdef AFS_DARWIN60_ENV
+ struct ifaddr *tifadp = (struct ifaddr *) 0;
+#else
struct in_ifaddr *tifadp = (struct in_ifaddr *) 0;
+#endif
extern struct ifnet *rxi_FindIfnet();
tifnp = rxi_FindIfnet(parm2, &tifadp); /* make iterative */
if (tifnp && tifadp) {
+#ifdef AFS_DARWIN60_ENV
+ mask = ((struct sockaddr_in *)tifadp->ifa_netmask)->sin_addr.s_addr;
+#else
mask = tifadp->ia_subnetmask;
+#endif
} else {
code = -1;
}
AFS_COPYIN((afs_int32 *)parm2, cellname, cellLen, code);
AFS_COPYIN((afs_int32 *)parm3, kmsg, kmsgLen, code);
if (!code) {
- code = afs_AfsdbHandler(cellname, cellLen, kmsg);
+ code = afs_AFSDBHandler(cellname, cellLen, kmsg);
if (*cellname == 1) *cellname = 0;
if (code == -2) { /* Shutting down? */
*cellname = 1;
code = copyin_iparam((char *)uap->parm3, &iparams);
if (code) {
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(code);
#endif
} else
}
#else
if (code) {
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(code);
#endif
}
#endif /* !AFS_LINUX20_ENV */
} else {
-#if defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- code = EINVAL;
-#else
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(EINVAL);
-#endif /* AFS_SUN5_ENV */
+#else
+ code = EINVAL;
+#endif
}
out:
#ifdef AFS_LINUX20_ENV
* incorrectly.
* Initstate of 300 means that the volume has been *successfully* looked up.
*/
-afs_CheckInit() {
+int afs_CheckInit(void)
+{
register int code = 0;
AFS_STATCNT(afs_CheckInit);
}
int afs_shuttingdown = 0;
-void
-afs_shutdown()
+void afs_shutdown(void)
{
extern short afs_brsDaemons;
extern afs_int32 afs_CheckServerDaemonStarted;
}
#ifdef AFS_AFSDB_ENV
afs_warn("AFSDB... ");
- afs_StopAfsdb();
+ afs_StopAFSDB();
while (afs_termState == AFSOP_STOP_AFSDB)
afs_osi_Sleep(&afs_termState);
#endif
while (afs_termState == AFSOP_STOP_RXEVENT)
afs_osi_Sleep(&afs_termState);
#if defined(RXK_LISTENER_ENV)
- afs_warn("RxListener... ");
#ifndef UKERNEL
+ afs_warn("UnmaskRxkSignals... ");
afs_osi_UnmaskRxkSignals();
#endif
/* cancel rx listener */
+ afs_warn("RxListener... ");
osi_StopListener(); /* This closes rx_socket. */
- while (afs_termState == AFSOP_STOP_RXK_LISTENER)
+ while (afs_termState == AFSOP_STOP_RXK_LISTENER) {
+ afs_warn("Sleep... ");
afs_osi_Sleep(&afs_termState);
+ }
#endif
#else
afs_termState = AFSOP_STOP_COMPLETE;
#endif
}
-shutdown_afstest()
+void shutdown_afstest(void)
{
AFS_STATCNT(shutdown_afstest);
afs_initState = afs_termState = afs_setTime = 0;
/* In case there is a bunch of dynamically build bkg daemons to free */
-afs_shutdown_BKG()
-{ AFS_STATCNT(shutdown_BKG); }
+void afs_shutdown_BKG(void)
+{
+ AFS_STATCNT(shutdown_BKG);
+}
#if defined(AFS_ALPHA_ENV) || defined(AFS_SGI61_ENV)
int afs_icl_inited = 0;
/* init function, called once, under afs_icl_lock */
-afs_icl_Init()
+int afs_icl_Init(void)
{
afs_icl_inited = 1;
return 0;
}
#else
if (!afs_suser()) { /* only root can run this code */
-#if !defined(AFS_SGI_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if defined(KERNEL_HAVE_SETUERROR)
setuerror(EACCES);
return EACCES;
#else
afs_lock_t afs_icl_lock;
/* exported routine: a 4 parameter event */
-afs_icl_Event4(setp, eventID, lAndT, p1, p2, p3, p4)
- register struct afs_icl_set *setp;
- afs_int32 eventID;
- afs_int32 lAndT;
- long p1, p2, p3, p4;
+int afs_icl_Event4(register struct afs_icl_set *setp, afs_int32 eventID,
+ afs_int32 lAndT, long p1, long p2, long p3, long p4)
{
register struct afs_icl_log *logp;
afs_int32 mask;
* Whole purpose is to avoid compiler warnings about parameter # mismatches.
* Otherwise, could call afs_icl_Event4 directly.
*/
-afs_icl_Event3(setp, eventID, lAndT, p1, p2, p3)
- register struct afs_icl_set *setp;
- afs_int32 eventID;
- afs_int32 lAndT;
- long p1, p2, p3;
+int afs_icl_Event3(register struct afs_icl_set *setp, afs_int32 eventID,
+ afs_int32 lAndT, long p1, long p2, long p3)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, p2, p3, (long)0);
}
-afs_icl_Event2(setp, eventID, lAndT, p1, p2)
- register struct afs_icl_set *setp;
- afs_int32 eventID;
- afs_int32 lAndT;
- long p1, p2;
+int afs_icl_Event2(register struct afs_icl_set *setp, afs_int32 eventID,
+ afs_int32 lAndT, long p1, long p2)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, p2, (long)0, (long)0);
}
-afs_icl_Event1(setp, eventID, lAndT, p1)
- register struct afs_icl_set *setp;
- afs_int32 eventID;
- afs_int32 lAndT;
- long p1;
+int afs_icl_Event1(register struct afs_icl_set *setp, afs_int32 eventID,
+ afs_int32 lAndT, long p1)
{
return afs_icl_Event4(setp, eventID, lAndT, p1, (long)0, (long)0, (long)0);
}
-afs_icl_Event0(setp, eventID, lAndT)
- register struct afs_icl_set *setp;
- afs_int32 eventID;
- afs_int32 lAndT;
+int afs_icl_Event0(register struct afs_icl_set *setp, afs_int32 eventID,
+ afs_int32 lAndT)
{
return afs_icl_Event4(setp, eventID, lAndT, (long)0, (long)0, (long)0, (long)0);
}
*
* Log must be write-locked.
*/
-static afs_icl_GetLogSpace(logp, minSpace)
- register struct afs_icl_log *logp;
- afs_int32 minSpace;
+static afs_icl_GetLogSpace(register struct afs_icl_log *logp, afs_int32 minSpace)
{
register unsigned int tsize;
* log must be write-locked.
*/
#define ICL_CHARSPERLONG 4
-static afs_int32 afs_icl_AppendString(logp, astr)
- struct afs_icl_log *logp;
- char *astr;
+static afs_int32 afs_icl_AppendString(struct afs_icl_log *logp, char *astr)
{
char *op; /* ptr to char to write */
int tc;
/* routine to tell whether we're dealing with the address or the
* object itself
*/
-afs_icl_UseAddr(type)
- int type;
+int afs_icl_UseAddr(int type)
{
if (type == ICL_TYPE_HYPER || type == ICL_TYPE_STRING
|| type == ICL_TYPE_FID || type == ICL_TYPE_INT64)
* pretty soon, anyway. The log must be unlocked.
*/
-afs_icl_AppendRecord(logp, op, types, p1, p2, p3, p4)
- register struct afs_icl_log *logp;
- afs_int32 op;
- afs_int32 types;
- long p1, p2, p3, p4;
+int afs_icl_AppendRecord(register struct afs_icl_log *logp, afs_int32 op,
+ afs_int32 types, long p1, long p2, long p3, long p4)
{
int rsize; /* record size in longs */
register int tsize; /* temp size */
/* create a log with size logSize; return it in *outLogpp and tag
* it with name "name."
*/
-afs_icl_CreateLog(name, logSize, outLogpp)
- char *name;
- afs_int32 logSize;
- struct afs_icl_log **outLogpp;
+int afs_icl_CreateLog(char *name, afs_int32 logSize, struct afs_icl_log **outLogpp)
{
return afs_icl_CreateLogWithFlags(name, logSize, /*flags*/0, outLogpp);
}
/* create a log with size logSize; return it in *outLogpp and tag
* it with name "name." 'flags' can be set to make the log unclearable.
*/
-afs_icl_CreateLogWithFlags(name, logSize, flags, outLogpp)
- char *name;
- afs_int32 logSize;
- afs_uint32 flags;
- struct afs_icl_log **outLogpp;
+int afs_icl_CreateLogWithFlags(char *name, afs_int32 logSize, afs_uint32 flags,
+ struct afs_icl_log **outLogpp)
{
register struct afs_icl_log *logp;
strcpy(logp->name, name);
LOCK_INIT(&logp->lock, "logp lock");
logp->logSize = logSize;
- logp->datap = (afs_int32 *)0; /* don't allocate it until we need it */
+ logp->datap = NULL; /* don't allocate it until we need it */
if (flags & ICL_CRLOG_FLAG_PERSISTENT)
logp->states |= ICL_LOGF_PERSISTENT;
* in *flagsp. The flag ICL_COPYOUTF_MISSEDSOME is set if we can't
* find the record with cookie value cookie.
*/
-afs_icl_CopyOut(logp, bufferp, bufSizep, cookiep, flagsp)
- register struct afs_icl_log *logp;
- afs_int32 *bufferp;
- afs_int32 *bufSizep;
- afs_uint32 *cookiep;
- afs_int32 *flagsp;
+int afs_icl_CopyOut(register struct afs_icl_log *logp, afs_int32 *bufferp,
+ afs_int32 *bufSizep, afs_uint32 *cookiep, afs_int32 *flagsp)
{
afs_int32 nwords; /* number of words to copy out */
afs_uint32 startCookie; /* first cookie to use */
}
/* return basic parameter information about a log */
-afs_icl_GetLogParms(logp, maxSizep, curSizep)
- struct afs_icl_log *logp;
- afs_int32 *maxSizep;
- afs_int32 *curSizep;
+int afs_icl_GetLogParms(struct afs_icl_log *logp, afs_int32 *maxSizep,
+ afs_int32 *curSizep)
{
ObtainReadLock(&logp->lock);
*maxSizep = logp->logSize;
/* hold and release logs */
-afs_icl_LogHold(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogHold(register struct afs_icl_log *logp)
{
ObtainWriteLock(&afs_icl_lock,187);
logp->refCount++;
}
/* hold and release logs, called with lock already held */
-afs_icl_LogHoldNL(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogHoldNL(register struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
}
/* keep track of how many sets believe the log itself is allocated */
-afs_icl_LogUse(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogUse(register struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock,188);
if (logp->setCount == 0) {
}
/* decrement the number of real users of the log, free if possible */
-afs_icl_LogFreeUse(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogFreeUse(register struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock,189);
if (--logp->setCount == 0) {
#endif
logp->firstUsed = logp->firstFree = 0;
logp->logElements = 0;
- logp->datap = (afs_int32 *)0;
+ logp->datap = NULL;
}
ReleaseWriteLock(&logp->lock);
return 0;
}
/* set the size of the log to 'logSize' */
-afs_icl_LogSetSize(logp, logSize)
- register struct afs_icl_log *logp;
- afs_int32 logSize;
+int afs_icl_LogSetSize(register struct afs_icl_log *logp, afs_int32 logSize)
{
ObtainWriteLock(&logp->lock,190);
if (!logp->datap) {
}
/* free a log. Called with afs_icl_lock locked. */
-afs_icl_ZapLog(logp)
- register struct afs_icl_log *logp;
+int afs_icl_ZapLog(register struct afs_icl_log *logp)
{
register struct afs_icl_log **lpp, *tp;
}
/* do the release, watching for deleted entries */
-afs_icl_LogRele(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogRele(register struct afs_icl_log *logp)
{
ObtainWriteLock(&afs_icl_lock,191);
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
}
/* do the release, watching for deleted entries, log already held */
-afs_icl_LogReleNL(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogReleNL(register struct afs_icl_log *logp)
{
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
afs_icl_ZapLog(logp); /* destroys logp's lock! */
}
/* zero out the log */
-afs_icl_ZeroLog(logp)
- register struct afs_icl_log *logp;
+int afs_icl_ZeroLog(register struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock,192);
logp->firstUsed = logp->firstFree = 0;
}
/* free a log entry, and drop its reference count */
-afs_icl_LogFree(logp)
- register struct afs_icl_log *logp;
+int afs_icl_LogFree(register struct afs_icl_log *logp)
{
ObtainWriteLock(&logp->lock,193);
logp->states |= ICL_LOGF_DELETED;
}
/* find a log by name, returning it held */
-struct afs_icl_log *afs_icl_FindLog(name)
- char *name;
+struct afs_icl_log *afs_icl_FindLog(char *name)
{
register struct afs_icl_log *tp;
ObtainWriteLock(&afs_icl_lock,194);
return tp;
}
-afs_icl_EnumerateLogs(aproc, arock)
- int (*aproc)();
- char *arock;
+int afs_icl_EnumerateLogs(int (*aproc)(), char *arock)
{
register struct afs_icl_log *tp;
register afs_int32 code;
struct afs_icl_set *afs_icl_allSets = 0;
-afs_icl_CreateSet(name, baseLogp, fatalLogp, outSetpp)
- char *name;
- struct afs_icl_log *baseLogp;
- struct afs_icl_log *fatalLogp;
- struct afs_icl_set **outSetpp;
+int afs_icl_CreateSet(char *name, struct afs_icl_log *baseLogp,
+ struct afs_icl_log *fatalLogp, struct afs_icl_set **outSetpp)
{
return afs_icl_CreateSetWithFlags(name, baseLogp, fatalLogp,
/*flags*/0, outSetpp);
* addds references from the new afs_icl_set. When the set is destroyed,
* those references will be released.
*/
-afs_icl_CreateSetWithFlags(name, baseLogp, fatalLogp, flags, outSetpp)
- char *name;
- struct afs_icl_log *baseLogp;
- struct afs_icl_log *fatalLogp;
- afs_uint32 flags;
- struct afs_icl_set **outSetpp;
+int afs_icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
+ struct afs_icl_log *fatalLogp, afs_uint32 flags, struct afs_icl_set **outSetpp)
{
register struct afs_icl_set *setp;
register int i;
}
/* function to change event enabling information for a particular set */
-afs_icl_SetEnable(setp, eventID, setValue)
- struct afs_icl_set *setp;
- afs_int32 eventID;
- int setValue;
+int afs_icl_SetEnable(struct afs_icl_set *setp, afs_int32 eventID, int setValue)
{
char *tp;
* for tracing. If *getValuep is set to 0, the event is disabled,
* otherwise it is enabled. All events start out enabled by default.
*/
-afs_icl_GetEnable(setp, eventID, getValuep)
- struct afs_icl_set *setp;
- afs_int32 eventID;
- int *getValuep;
+int afs_icl_GetEnable(struct afs_icl_set *setp, afs_int32 eventID,
+ int *getValuep)
{
ObtainReadLock(&setp->lock);
if (!ICL_EVENTOK(setp, eventID)) {
}
/* hold and release event sets */
-afs_icl_SetHold(setp)
- register struct afs_icl_set *setp;
+int afs_icl_SetHold(register struct afs_icl_set *setp)
{
ObtainWriteLock(&afs_icl_lock,201);
setp->refCount++;
}
/* free a set. Called with afs_icl_lock locked */
-afs_icl_ZapSet(setp)
- register struct afs_icl_set *setp;
+int afs_icl_ZapSet(register struct afs_icl_set *setp)
{
register struct afs_icl_set **lpp, *tp;
int i;
unpin((char *)setp->eventFlags, ICL_DEFAULTEVENTS);
#endif
for(i=0; i < ICL_LOGSPERSET; i++) {
- if (tlp = setp->logs[i])
+ if ((tlp = setp->logs[i]))
afs_icl_LogReleNL(tlp);
}
osi_FreeSmallSpace(setp);
}
/* do the release, watching for deleted entries */
-afs_icl_SetRele(setp)
- register struct afs_icl_set *setp;
+int afs_icl_SetRele(register struct afs_icl_set *setp)
{
ObtainWriteLock(&afs_icl_lock,202);
if (--setp->refCount == 0 && (setp->states & ICL_SETF_DELETED)) {
}
/* free a set entry, dropping its reference count */
-afs_icl_SetFree(setp)
- register struct afs_icl_set *setp;
+int afs_icl_SetFree(register struct afs_icl_set *setp)
{
ObtainWriteLock(&setp->lock,203);
setp->states |= ICL_SETF_DELETED;
}
/* find a set by name, returning it held */
-struct afs_icl_set *afs_icl_FindSet(name)
- char *name;
+struct afs_icl_set *afs_icl_FindSet(char *name)
{
register struct afs_icl_set *tp;
ObtainWriteLock(&afs_icl_lock,204);
}
/* zero out all the logs in the set */
-afs_icl_ZeroSet(setp)
- struct afs_icl_set *setp;
+int afs_icl_ZeroSet(struct afs_icl_set *setp)
{
register int i;
int code = 0;
return code;
}
-afs_icl_EnumerateSets(aproc, arock)
- int (*aproc)();
- char *arock;
+int afs_icl_EnumerateSets(int (*aproc)(), char *arock)
{
register struct afs_icl_set *tp, *np;
register afs_int32 code;
return code;
}
-afs_icl_AddLogToSet(setp, newlogp)
- struct afs_icl_set *setp;
- struct afs_icl_log *newlogp;
+int afs_icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
{
register int i;
int code = -1;
return code;
}
-afs_icl_SetSetStat(setp, op)
- struct afs_icl_set *setp;
- int op;
+int afs_icl_SetSetStat(struct afs_icl_set *setp, int op)
{
int i;
afs_int32 code;
git://git.openafs.org / openafs.git / blobdiff