/*
* 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
#define AFS_MINBUFFERS 50
#endif
+#if ((defined(AFS_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)) || defined(AFS_DARWIN80_ENV)) && !defined(UKERNEL)
+/* If AFS_DAEMONOP_ENV is defined, it indicates we run "daemon" AFS syscalls by
+ * spawning a kernel thread to do the work, instead of running them in the
+ * calling process. */
+# define AFS_DAEMONOP_ENV
+#endif
+
struct afsop_cell {
afs_int32 hosts[AFS_MAXCELLHOSTS];
char cellName[100];
memset(afs_zeros, 0, AFS_ZEROS);
+ rx_SetBusyChannelError(RX_CALL_TIMEOUT);
+
/* start RX */
if(!afscall_set_rxpck_received)
rx_extraPackets = AFS_NRXPACKETS; /* smaller # of packets */
return code;
}
+
+#ifdef AFS_DAEMONOP_ENV
+static int
+daemonOp_common(long parm, long parm2, long parm3, long parm4, long parm5,
+ long parm6)
+{
+ int code;
+ if (parm == AFSOP_START_RXCALLBACK) {
+ if (afs_CB_Running)
+ return -1;
+# ifdef RXK_LISTENER_ENV
+ } else if (parm == AFSOP_RXLISTENER_DAEMON) {
+ if (afs_RX_Running)
+ return -1;
+ afs_RX_Running = 1;
+# endif
+ code = afs_InitSetup(parm2);
+ if (parm3) {
+ rx_enablePeerRPCStats();
+ }
+ if (parm4) {
+ rx_enableProcessRPCStats();
+ }
+ if (code)
+ return -1;
+ } else if (parm == AFSOP_START_AFS) {
+ if (AFS_Running)
+ return -1;
+ } /* other functions don't need setup in the parent */
+ return 0;
+}
+#endif /* AFS_DAEMONOP_ENV */
+
#if defined(AFS_DARWIN80_ENV)
struct afsd_thread_info {
unsigned long parm;
AFS_GLOCK();
wakeup(arg);
afs_CB_Running = 1;
+#ifndef RXK_LISTENER_ENV
+ afs_initState = AFSOP_START_AFS;
+ afs_osi_Wakeup(&afs_initState);
+#else
while (afs_RX_Running != 2)
afs_osi_Sleep(&afs_RX_Running);
+#endif
afs_RXCallBackServer();
AFS_GUNLOCK();
thread_terminate(current_thread());
AFS_GUNLOCK();
thread_terminate(current_thread());
break;
+#ifdef RXK_LISTENER_ENV
case AFSOP_RXLISTENER_DAEMON:
AFS_GLOCK();
wakeup(arg);
AFS_GUNLOCK();
thread_terminate(current_thread());
break;
+#endif
default:
afs_warn("Unknown op %ld in StartDaemon()\n", (long)parm);
break;
afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
long parm6)
{
- int code;
struct afsd_thread_info info;
thread_t thread;
-
- if (parm == AFSOP_START_RXCALLBACK) {
- if (afs_CB_Running)
- return;
- } else if (parm == AFSOP_RXLISTENER_DAEMON) {
- if (afs_RX_Running)
- return;
- afs_RX_Running = 1;
- code = afs_InitSetup(parm2);
- if (parm3) {
- rx_enablePeerRPCStats();
- }
- if (parm4) {
- rx_enableProcessRPCStats();
- }
- if (code)
- return;
- } else if (parm == AFSOP_START_AFS) {
- if (AFS_Running)
- return;
- } /* other functions don't need setup in the parent */
+ if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
+ return;
+ }
info.parm = parm;
kernel_thread_start((thread_continue_t)afsd_thread, &info, &thread);
AFS_GUNLOCK();
#if defined(AFS_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)
struct afsd_thread_info {
-#if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
+# if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
struct work_struct tq;
-#endif
+# endif
unsigned long parm;
struct completion *complete;
};
{
struct afsd_thread_info *arg = rock;
unsigned long parm = arg->parm;
-#ifdef SYS_SETPRIORITY_EXPORTED
+# ifdef SYS_SETPRIORITY_EXPORTED
int (*sys_setpriority) (int, int, int) = sys_call_table[__NR_setpriority];
-#endif
-#if defined(AFS_LINUX26_ENV)
+# endif
+# if defined(AFS_LINUX26_ENV)
daemonize("afsd");
-#else
+# else
daemonize();
-#endif
+# endif
/* doesn't do much, since we were forked from keventd, but
* does call mm_release, which wakes up our parent (since it
* used CLONE_VFORK) */
-#if !defined(AFS_LINUX26_ENV)
+# if !defined(AFS_LINUX26_ENV)
reparent_to_init();
-#endif
+# endif
afs_osi_MaskSignals();
switch (parm) {
case AFSOP_START_RXCALLBACK:
AFS_GLOCK();
complete(arg->complete);
afs_CB_Running = 1;
+#if !defined(RXK_LISTENER_ENV)
+ afs_initState = AFSOP_START_AFS;
+ afs_osi_Wakeup(&afs_initState);
+#else
while (afs_RX_Running != 2)
afs_osi_Sleep(&afs_RX_Running);
+#endif
sprintf(current->comm, "afs_callback");
afs_RXCallBackServer();
AFS_GUNLOCK();
break;
case AFSOP_RXEVENT_DAEMON:
sprintf(current->comm, "afs_evtstart");
-#ifdef SYS_SETPRIORITY_EXPORTED
+# ifdef SYS_SETPRIORITY_EXPORTED
sys_setpriority(PRIO_PROCESS, 0, -10);
-#else
-#ifdef CURRENT_INCLUDES_NICE
+# else
+# ifdef CURRENT_INCLUDES_NICE
current->nice = -10;
-#endif
-#endif
+# endif
+# endif
AFS_GLOCK();
complete(arg->complete);
while (afs_initState < AFSOP_START_BKG)
AFS_GUNLOCK();
complete_and_exit(0, 0);
break;
+#ifdef RXK_LISTENER_ENV
case AFSOP_RXLISTENER_DAEMON:
sprintf(current->comm, "afs_lsnstart");
-#ifdef SYS_SETPRIORITY_EXPORTED
+# ifdef SYS_SETPRIORITY_EXPORTED
sys_setpriority(PRIO_PROCESS, 0, -10);
-#else
-#ifdef CURRENT_INCLUDES_NICE
+# else
+# ifdef CURRENT_INCLUDES_NICE
current->nice = -10;
-#endif
-#endif
+# endif
+# endif
AFS_GLOCK();
complete(arg->complete);
afs_initState = AFSOP_START_AFS;
AFS_GUNLOCK();
complete_and_exit(0, 0);
break;
+#endif
default:
afs_warn("Unknown op %ld in StartDaemon()\n", (long)parm);
break;
}
void
-#if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
+# if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
afsd_launcher(struct work_struct *work)
-#else
+# else
afsd_launcher(void *rock)
-#endif
+# endif
{
-#if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
+# if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
struct afsd_thread_info *rock = container_of(work, struct afsd_thread_info, tq);
-#endif
+# endif
if (!kernel_thread(afsd_thread, (void *)rock, CLONE_VFORK | SIGCHLD))
afs_warn("kernel_thread failed. afs startup will not complete\n");
afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
long parm6)
{
- int code;
DECLARE_COMPLETION(c);
-#if defined(AFS_LINUX26_ENV)
-#if defined(INIT_WORK_HAS_DATA)
+# if defined(AFS_LINUX26_ENV)
+# if defined(INIT_WORK_HAS_DATA)
struct work_struct tq;
-#endif
-#else
+# endif
+# else
struct tq_struct tq;
-#endif
+# endif
struct afsd_thread_info info;
- if (parm == AFSOP_START_RXCALLBACK) {
- if (afs_CB_Running)
- return;
- } else if (parm == AFSOP_RXLISTENER_DAEMON) {
- if (afs_RX_Running)
- return;
- afs_RX_Running = 1;
- code = afs_InitSetup(parm2);
- if (parm3) {
- rx_enablePeerRPCStats();
- }
- if (parm4) {
- rx_enableProcessRPCStats();
- }
- if (code)
- return;
- } else if (parm == AFSOP_START_AFS) {
- if (AFS_Running)
- return;
- } /* other functions don't need setup in the parent */
+ if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
+ return;
+ }
info.complete = &c;
info.parm = parm;
-#if defined(AFS_LINUX26_ENV)
-#if !defined(INIT_WORK_HAS_DATA)
+# if defined(AFS_LINUX26_ENV)
+# if !defined(INIT_WORK_HAS_DATA)
INIT_WORK(&info.tq, afsd_launcher);
schedule_work(&info.tq);
-#else
+# else
INIT_WORK(&tq, afsd_launcher, &info);
schedule_work(&tq);
-#endif
-#else
+# endif
+# else
tq.sync = 0;
INIT_LIST_HEAD(&tq.list);
tq.routine = afsd_launcher;
tq.data = &info;
schedule_task(&tq);
-#endif
+# endif
AFS_GUNLOCK();
/* we need to wait cause we passed stack pointers around.... */
wait_for_completion(&c);
#endif
#ifdef AFS_DARWIN100_ENV
-#define AFSKPTR(X) k ## X
+# define AFSKPTR(X) k ## X
int
afs_syscall_call(long parm, long parm2, long parm3,
long parm4, long parm5, long parm6)
CAST_USER_ADDR_T((parm6)));
}
#else
-#define AFSKPTR(X) ((caddr_t)X)
+# define AFSKPTR(X) ((caddr_t)X)
#endif
int
#ifdef AFS_DARWIN100_ENV
&& (parm != AFSOP_GETMTU) && (parm != AFSOP_GETMASK)) {
/* only root can run this code */
#if defined(AFS_SUN5_ENV) || defined(KERNEL_HAVE_UERROR)
-#if defined(KERNEL_HAVE_UERROR)
+# if defined(KERNEL_HAVE_UERROR)
setuerror(EACCES);
-#endif
+# endif
code = EACCES;
#else
code = EPERM;
#ifdef AFS_DARWIN80_ENV
put_vfs_context();
#endif
-#if ((defined(AFS_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)) || defined(AFS_DARWIN80_ENV)) && !defined(UKERNEL)
-#if defined(AFS_DARWIN80_ENV)
+#ifdef AFS_DAEMONOP_ENV
+# if defined(AFS_DARWIN80_ENV)
if (parm == AFSOP_BKG_HANDLER) {
/* if afs_uspc_param grows this should be checked */
struct afs_uspc_param *mvParam = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
sizeof(struct afs_uspc_param), code);
namebufsz = mvParam->bufSz;
param1 = afs_osi_Alloc(namebufsz);
+ osi_Assert(param1 != NULL);
param2 = afs_osi_Alloc(namebufsz);
+ osi_Assert(param2 != NULL);
while (afs_initState < AFSOP_START_BKG)
afs_osi_Sleep(&afs_initState);
afs_osi_Free(param2, namebufsz);
osi_FreeSmallSpace(mvParam);
} else
-#endif /* DARWIN80 */
+# endif /* DARWIN80 */
if (parm < AFSOP_ADDCELL || parm == AFSOP_RXEVENT_DAEMON
|| parm == AFSOP_RXLISTENER_DAEMON) {
afs_DaemonOp(parm, parm2, parm3, parm4, parm5, parm6);
}
-#else /* !(AFS_LINUX24_ENV && !UKERNEL) */
+#else /* !AFS_DAEMONOP_ENV */
if (parm == AFSOP_START_RXCALLBACK) {
if (afs_CB_Running)
goto out;
afs_CB_Running = 1;
-#ifndef RXK_LISTENER_ENV
+# ifndef RXK_LISTENER_ENV
code = afs_InitSetup(parm2);
if (!code)
-#endif /* !RXK_LISTENER_ENV */
+# endif /* !RXK_LISTENER_ENV */
{
-#ifdef RXK_LISTENER_ENV
+# ifdef RXK_LISTENER_ENV
while (afs_RX_Running != 2)
afs_osi_Sleep(&afs_RX_Running);
-#else /* !RXK_LISTENER_ENV */
+# else /* !RXK_LISTENER_ENV */
+ if (parm3) {
+ rx_enablePeerRPCStats();
+ }
+ if (parm4) {
+ rx_enableProcessRPCStats();
+ }
afs_initState = AFSOP_START_AFS;
afs_osi_Wakeup(&afs_initState);
-#endif /* RXK_LISTENER_ENV */
+# endif /* RXK_LISTENER_ENV */
afs_osi_Invisible();
afs_RXCallBackServer();
afs_osi_Visible();
}
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, code);
-#endif /* AFS_SGI_ENV */
+# endif /* AFS_SGI_ENV */
}
-#ifdef RXK_LISTENER_ENV
+# ifdef RXK_LISTENER_ENV
else if (parm == AFSOP_RXLISTENER_DAEMON) {
if (afs_RX_Running)
goto out;
afs_osi_Invisible();
afs_RX_Running = 2;
afs_osi_Wakeup(&afs_RX_Running);
-#ifndef UKERNEL
+# ifndef UKERNEL
afs_osi_RxkRegister();
-#endif /* !UKERNEL */
+# endif /* !UKERNEL */
rxk_Listener();
afs_osi_Visible();
}
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, code);
-#endif /* AFS_SGI_ENV */
+# endif /* AFS_SGI_ENV */
}
-#endif /* RXK_LISTENER_ENV */
+# endif /* RXK_LISTENER_ENV */
else if (parm == AFSOP_START_AFS) {
/* afs daemon */
if (AFS_Running)
afs_osi_Invisible();
afs_Daemon();
afs_osi_Visible();
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, 0);
-#endif /* AFS_SGI_ENV */
+# endif /* AFS_SGI_ENV */
} else if (parm == AFSOP_START_CS) {
afs_osi_Invisible();
afs_CheckServerDaemon();
afs_osi_Visible();
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, 0);
-#endif /* AFS_SGI_ENV */
-#ifndef AFS_DARWIN80_ENV
+# endif /* AFS_SGI_ENV */
+# ifndef AFS_DARWIN80_ENV
} else if (parm == AFSOP_START_BKG) {
while (afs_initState < AFSOP_START_BKG)
afs_osi_Sleep(&afs_initState);
}
/* start the bkg daemon */
afs_osi_Invisible();
-# ifdef AFS_AIX32_ENV
+# ifdef AFS_AIX32_ENV
if (parm2)
afs_BioDaemon(parm2);
else
-# endif /* AFS_AIX32_ENV */
+# endif /* AFS_AIX32_ENV */
afs_BackgroundDaemon();
afs_osi_Visible();
-# ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, 0);
-# endif /* AFS_SGI_ENV */
-#endif /* ! AFS_DARWIN80_ENV */
+# endif /* AFS_SGI_ENV */
+# endif /* ! AFS_DARWIN80_ENV */
} else if (parm == AFSOP_START_TRUNCDAEMON) {
while (afs_initState < AFSOP_GO)
afs_osi_Sleep(&afs_initState);
afs_osi_Invisible();
afs_CacheTruncateDaemon();
afs_osi_Visible();
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, 0);
-#endif /* AFS_SGI_ENV */
+# endif /* AFS_SGI_ENV */
}
-#if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
+# if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
else if (parm == AFSOP_RXEVENT_DAEMON) {
while (afs_initState < AFSOP_START_BKG)
afs_osi_Sleep(&afs_initState);
afs_osi_Invisible();
afs_rxevent_daemon();
afs_osi_Visible();
-#ifdef AFS_SGI_ENV
+# ifdef AFS_SGI_ENV
AFS_GUNLOCK();
exit(CLD_EXITED, 0);
-#endif /* AFS_SGI_ENV */
+# endif /* AFS_SGI_ENV */
}
-#endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV */
-#endif /* AFS_LINUX24_ENV && !UKERNEL */
+# endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV */
+#endif /* AFS_DAEMONOP_ENV */
else if (parm == AFSOP_BASIC_INIT) {
afs_int32 temp;
case 2:
afs_tpct2 = parm3;
break;
- }
+ }
} else if (parm == AFSOP_ADDCELL) {
/* add a cell. Parameter 2 is 8 hosts (in net order), parm 3 is the null-terminated
* name. Parameter 4 is the length of the name, including the null. Parm 5 is the
* home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
+ osi_Assert(tcell != NULL);
code = afs_InitDynroot();
if (!code) {
AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts),
char *tbuffer1 = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
int cflags = parm4;
+ osi_Assert(tcell != NULL);
+ osi_Assert(tbuffer != NULL);
+ osi_Assert(tbuffer1 != NULL);
code = afs_InitDynroot();
if (!code) {
#if 0
afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
cparms.cacheBlocks, cparms.cacheDcaches,
cparms.cacheVolumes, cparms.chunkSize,
- cparms.memCacheFlag, cparms.inodes, cparms.users,
+ cparms.memCacheFlag, cparms.inodes, cparms.users,
cparms.dynamic_vcaches);
} else if (parm == AFSOP_CACHEINODE) {
afs_tpct1 = 0;
afs_tpct2 = 0;
splitdcache = 0;
- } else {
+ } else {
splitdcache = 1;
}
afs_osi_Wakeup(&afs_initState);
afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
int i;
+ osi_Assert(buffer != NULL);
+ osi_Assert(maskbuffer != NULL);
+ osi_Assert(mtubuffer != NULL);
/* This is a refresh */
if (count & 0x40000000) {
count &= ~0x40000000;
refresh = 1;
}
- /* Bind, but only if there's only one address configured */
+ /* Bind, but only if there's only one address configured */
if ( count & 0x80000000) {
count &= ~0x80000000;
if (count == 1)
nfs_rfsdisptab_v2 = (int (*)())parm2;
} else if (parm == AFSOP_NFSSTATICADDR2) {
extern int (*nfs_rfsdisptab_v2) ();
-#ifdef _K64U64
+# ifdef _K64U64
nfs_rfsdisptab_v2 = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
-#else /* _K64U64 */
+# else /* _K64U64 */
nfs_rfsdisptab_v2 = (int (*)())(parm3 & 0xffffffff);
-#endif /* _K64U64 */
+# endif /* _K64U64 */
}
-#if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
+# if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
else if (parm == AFSOP_SBLOCKSTATICADDR2) {
extern int (*afs_sblockp) ();
extern void (*afs_sbunlockp) ();
-#ifdef _K64U64
+# ifdef _K64U64
afs_sblockp = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
afs_sbunlockp = (void (*)())((parm4 << 32) | (parm5 & 0xffffffff));
-#else
+# else
afs_sblockp = (int (*)())(parm3 & 0xffffffff);
afs_sbunlockp = (void (*)())(parm5 & 0xffffffff);
-#endif /* _K64U64 */
+# endif /* _K64U64 */
}
-#endif /* AFS_SGI62_ENV && !AFS_SGI65_ENV */
+# endif /* AFS_SGI62_ENV && !AFS_SGI65_ENV */
#endif /* AFS_SGI53_ENV */
else if (parm == AFSOP_SHUTDOWN) {
afs_cold_shutdown = 0;
#ifdef AFS_HPUX_ENV
vfsmount(parm2, parm3, parm4, parm5);
#else /* defined(AFS_HPUX_ENV) */
-#if defined(KERNEL_HAVE_UERROR)
+# if defined(KERNEL_HAVE_UERROR)
setuerror(EINVAL);
-#else
+# else
code = EINVAL;
-#endif
+# endif
#endif /* defined(AFS_HPUX_ENV) */
} else if (parm == AFSOP_CLOSEWAIT) {
afs_SynchronousCloses = 'S';
} else if (parm == AFSOP_GETMTU) {
afs_uint32 mtu = 0;
#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
-#ifdef AFS_USERSPACE_IP_ADDR
+# ifdef AFS_USERSPACE_IP_ADDR
afs_int32 i;
i = rxi_Findcbi(parm2);
mtu = ((i == -1) ? htonl(1500) : afs_cb_interface.mtu[i]);
-#else /* AFS_USERSPACE_IP_ADDR */
+# else /* AFS_USERSPACE_IP_ADDR */
rx_ifnet_t tifnp;
tifnp = rxi_FindIfnet(parm2, NULL); /* make iterative */
mtu = (tifnp ? rx_ifnet_mtu(tifnp) : htonl(1500));
-#endif /* else AFS_USERSPACE_IP_ADDR */
+# endif /* else AFS_USERSPACE_IP_ADDR */
#endif /* !AFS_SUN5_ENV */
if (!code)
AFS_COPYOUT((caddr_t) & mtu, AFSKPTR(parm3),
extern u_long sb_max_dflt;
if (!adjusted) {
adjusted = 1;
- if (sb_max_dflt < 131072) sb_max_dflt = 131072;
- if (sb_max < 131072) sb_max = 131072;
+ if (sb_max_dflt < 131072) sb_max_dflt = 131072;
+ if (sb_max < 131072) sb_max = 131072;
}
} */
#endif /* AFS_AIX32_ENV */
} else if (parm == AFSOP_GETMASK) { /* parm2 == addr in net order */
afs_uint32 mask = 0;
#if !defined(AFS_SUN5_ENV)
-#ifdef AFS_USERSPACE_IP_ADDR
+# ifdef AFS_USERSPACE_IP_ADDR
afs_int32 i;
i = rxi_Findcbi(parm2);
if (i != -1) {
} else {
code = -1;
}
-#else /* AFS_USERSPACE_IP_ADDR */
+# else /* AFS_USERSPACE_IP_ADDR */
rx_ifnet_t tifnp;
tifnp = rxi_FindIfnet(parm2, &mask); /* make iterative */
if (!tifnp)
code = -1;
-#endif /* else AFS_USERSPACE_IP_ADDR */
+# endif /* else AFS_USERSPACE_IP_ADDR */
#endif /* !AFS_SUN5_ENV */
if (!code)
AFS_COPYOUT((caddr_t) & mask, AFSKPTR(parm3),
afs_int32 *kmsg = afs_osi_Alloc(kmsgLen);
char *cellname = afs_osi_Alloc(cellLen);
+ osi_Assert(kmsg != NULL);
+ osi_Assert(cellname != NULL);
#ifndef UKERNEL
afs_osi_MaskUserLoop();
#endif
int
afs_CheckInit(void)
{
- register int code = 0;
+ int code = 0;
AFS_STATCNT(afs_CheckInit);
if (afs_initState <= 100)
if (afs_shuttingdown)
return;
+ afs_FlushVCBs(2); /* Reasonable effort to free dynamically allocated callback returns */
+
afs_shuttingdown = 1;
if (afs_cold_shutdown)
afs_warn("afs: COLD ");
/* cancel rx event daemon */
while (afs_termState == AFSOP_STOP_RXEVENT)
afs_osi_Sleep(&afs_termState);
-#if defined(RXK_LISTENER_ENV)
-#ifndef UKERNEL
+# if defined(RXK_LISTENER_ENV)
+# ifndef UKERNEL
afs_warn("UnmaskRxkSignals... ");
afs_osi_UnmaskRxkSignals();
-#endif
+# endif
/* cancel rx listener */
afs_warn("RxListener... ");
osi_StopListener(); /* This closes rx_socket. */
afs_warn("Sleep... ");
afs_osi_Sleep(&afs_termState);
}
-#endif
+# endif
#endif
-#ifdef AFS_SUN510_ENV
+#if defined(AFS_SUN510_ENV) || defined(RXK_UPCALL_ENV)
afs_warn("NetIfPoller... ");
osi_StopNetIfPoller();
#endif
git://git.openafs.org / openafs.git / blobdiff