#include "netinet/in_var.h"
#endif
#endif /* !defined(UKERNEL) */
-#ifdef AFS_LINUX22_ENV
-#include "h/smp_lock.h"
-#endif
#ifdef AFS_SUN510_ENV
#include "h/ksynch.h"
#include "h/sunddi.h"
#define AFS_MINBUFFERS 50
#endif
+#if (defined(AFS_SUN5_ENV) || (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];
afs_int32 afs_initState = 0;
afs_int32 afs_termState = 0;
-afs_int32 afs_setTime = 0;
int afs_cold_shutdown = 0;
char afs_SynchronousCloses = '\0';
static int afs_CB_Running = 0;
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_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;
-#ifdef RXK_LISTENER_ENV
- } else if (parm == AFSOP_RXLISTENER_DAEMON) {
- if (afs_RX_Running)
- return;
- afs_RX_Running = 1;
-#endif
- 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();
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)
struct tq_struct tq;
# endif
struct afsd_thread_info info;
- if (parm == AFSOP_START_RXCALLBACK) {
- if (afs_CB_Running)
- return;
-#ifdef RXK_LISTENER_ENV
- } else if (parm == AFSOP_RXLISTENER_DAEMON) {
- if (afs_RX_Running)
- return;
- afs_RX_Running = 1;
-#endif
- 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)
}
#endif
+#ifdef AFS_SUN5_ENV
+struct afs_daemonop_args {
+ kcondvar_t cv;
+ long parm;
+};
+
+static void
+afsd_thread(struct afs_daemonop_args *args)
+{
+ long parm = args->parm;
+
+ AFS_GLOCK();
+ cv_signal(&args->cv);
+
+ switch (parm) {
+ case AFSOP_START_RXCALLBACK:
+ if (afs_CB_Running)
+ goto out;
+ afs_CB_Running = 1;
+ while (afs_RX_Running != 2)
+ afs_osi_Sleep(&afs_RX_Running);
+ afs_RXCallBackServer();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_START_AFS:
+ 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_Daemon();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_START_BKG:
+ while (afs_initState < AFSOP_START_BKG)
+ afs_osi_Sleep(&afs_initState);
+ if (afs_initState < AFSOP_GO) {
+ afs_initState = AFSOP_GO;
+ afs_osi_Wakeup(&afs_initState);
+ }
+ afs_BackgroundDaemon();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_START_TRUNCDAEMON:
+ while (afs_initState < AFSOP_GO)
+ afs_osi_Sleep(&afs_initState);
+ afs_CacheTruncateDaemon();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_START_CS:
+ afs_CheckServerDaemon();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_RXEVENT_DAEMON:
+ while (afs_initState < AFSOP_START_BKG)
+ afs_osi_Sleep(&afs_initState);
+ afs_rxevent_daemon();
+ AFS_GUNLOCK();
+ return;
+ case AFSOP_RXLISTENER_DAEMON:
+ afs_initState = AFSOP_START_AFS;
+ afs_osi_Wakeup(&afs_initState);
+ afs_RX_Running = 2;
+ afs_osi_Wakeup(&afs_RX_Running);
+ afs_osi_RxkRegister();
+ rxk_Listener();
+ AFS_GUNLOCK();
+ return;
+ default:
+ AFS_GUNLOCK();
+ afs_warn("Unknown op %ld in afsd_thread()\n", parm);
+ return;
+ }
+ out:
+ AFS_GUNLOCK();
+ return;
+}
+
+static void
+afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
+ long parm6)
+{
+ struct afs_daemonop_args args;
+
+ if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
+ return;
+ }
+
+ args.parm = parm;
+
+ cv_init(&args.cv, "AFS DaemonOp cond var", CV_DEFAULT, NULL);
+
+ if (thread_create(NULL, 0, afsd_thread, &args, 0, &p0, TS_RUN,
+ minclsyspri) == NULL) {
+
+ afs_warn("thread_create failed: AFS startup will not complete\n");
+ }
+
+ /* we passed &args to the new thread, which is on the stack. wait until
+ * it has read the arguments so it doesn't try to read the args after we
+ * have returned */
+ cv_wait(&args.cv, &afs_global_lock);
+
+ cv_destroy(&args.cv);
+}
+#endif /* AFS_SUN5_ENV */
+
#ifdef AFS_DARWIN100_ENV
# define AFSKPTR(X) k ## X
int
#endif
{
afs_int32 code = 0;
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_SGI61_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
size_t bufferSize;
#else /* AFS_SGI61_ENV */
u_int bufferSize;
#ifdef AFS_DARWIN80_ENV
put_vfs_context();
#endif
-#if ((defined(AFS_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)) || defined(AFS_DARWIN80_ENV)) && !defined(UKERNEL)
+#ifdef AFS_DAEMONOP_ENV
# if defined(AFS_DARWIN80_ENV)
if (parm == AFSOP_BKG_HANDLER) {
/* if afs_uspc_param grows this should be checked */
|| 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;
exit(CLD_EXITED, 0);
# endif /* AFS_SGI_ENV */
}
-# if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
+# if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV) || defined(RXK_UPCALL_ENV)
else if (parm == AFSOP_RXEVENT_DAEMON) {
while (afs_initState < AFSOP_START_BKG)
afs_osi_Sleep(&afs_initState);
exit(CLD_EXITED, 0);
# endif /* AFS_SGI_ENV */
}
-# endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV */
-#endif /* AFS_LINUX24_ENV && !UKERNEL */
+# endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV || RXK_UPCALL_ENV */
+#endif /* AFS_DAEMONOP_ENV */
else if (parm == AFSOP_BASIC_INIT) {
afs_int32 temp;
}
afs_CacheInit_Done = 1;
code = afs_icl_InitLogs();
- afs_setTime = cparms.setTimeFlag;
+ if (cparms.setTimeFlag) {
+ afs_warn("afs: AFSOP_CACHEINIT setTimeFlag ignored; are you "
+ "running an old afsd?\n");
+ }
code =
afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
while (afs_initState < AFSOP_GO)
afs_osi_Sleep(&afs_initState);
afs_initState = 101;
- afs_setTime = parm2;
+ if (parm2) {
+ /* parm2 used to set afs_setTime */
+ afs_warn("afs: AFSOP_GO setTime flag ignored; are you running an "
+ "old afsd?\n");
+ }
if (afs_tpct1 + afs_tpct2 != 100) {
afs_tpct1 = 0;
afs_tpct2 = 0;
#if (!defined(AFS_NONFSTRANS)) || defined(AFS_AIX_IAUTH_ENV)
afs_nfsclient_init();
#endif
- afs_uuid_create(&afs_cb_interface.uuid);
+ if (afs_uuid_create(&afs_cb_interface.uuid) != 0)
+ memset(&afs_cb_interface.uuid, 0, sizeof(afsUUID));
+
printf("found %d non-empty cache files (%d%%).\n",
afs_stats_cmperf.cacheFilesReused,
(100 * afs_stats_cmperf.cacheFilesReused) /
if (refresh) {
afs_CheckServers(1, NULL); /* check down servers */
- afs_CheckServers(0, NULL); /* check down servers */
+ afs_CheckServers(0, NULL); /* check up servers */
}
}
-#ifdef AFS_SGI53_ENV
- else if (parm == AFSOP_NFSSTATICADDR) {
- extern int (*nfs_rfsdisptab_v2) ();
- nfs_rfsdisptab_v2 = (int (*)())parm2;
- } else if (parm == AFSOP_NFSSTATICADDR2) {
- extern int (*nfs_rfsdisptab_v2) ();
-# ifdef _K64U64
- nfs_rfsdisptab_v2 = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
-# else /* _K64U64 */
- nfs_rfsdisptab_v2 = (int (*)())(parm3 & 0xffffffff);
-# endif /* _K64U64 */
- }
-# if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
- else if (parm == AFSOP_SBLOCKSTATICADDR2) {
- extern int (*afs_sblockp) ();
- extern void (*afs_sbunlockp) ();
-# ifdef _K64U64
- afs_sblockp = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
- afs_sbunlockp = (void (*)())((parm4 << 32) | (parm5 & 0xffffffff));
-# else
- afs_sblockp = (int (*)())(parm3 & 0xffffffff);
- afs_sbunlockp = (void (*)())(parm5 & 0xffffffff);
-# endif /* _K64U64 */
- }
-# endif /* AFS_SGI62_ENV && !AFS_SGI65_ENV */
-#endif /* AFS_SGI53_ENV */
else if (parm == AFSOP_SHUTDOWN) {
afs_cold_shutdown = 0;
if (parm2 == 1)
afscall_set_rxpck_received = 1;
} else if (parm == AFSOP_SET_RXMAXMTU) {
rx_MyMaxSendSize = rx_maxReceiveSizeUser = rx_maxReceiveSize = parm2;
+ } else if (parm == AFSOP_SET_RXMAXFRAGS) {
+ rxi_nSendFrags = rxi_nRecvFrags = parm2;
} else {
code = EINVAL;
}
if (afs_shuttingdown)
return;
- afs_FlushVCBs(2); /* Reasonable effort to free dynamically allocated callback returns */
+
+ /* Give up all of our callbacks if we can. This must be done before setting
+ * afs_shuttingdown, since it calls afs_InitReq, which will fail if
+ * afs_shuttingdown is set. */
+ afs_FlushVCBs(2);
afs_shuttingdown = 1;
+
if (afs_cold_shutdown)
afs_warn("afs: COLD ");
else
afs_warn("afs: WARM ");
- afs_warn("shutting down of: CB... ");
+ afs_warn("shutting down of: vcaches... ");
+
+#if !defined(AFS_FBSD_ENV)
+ /* The FBSD afs_unmount() calls vflush(), which reclaims all vnodes
+ * on the mountpoint, flushing them in the process. In the presence
+ * of bugs, flushing again here can cause panics. */
+ afs_FlushAllVCaches();
+#endif
+
+ afs_warn("CB... ");
afs_termState = AFSOP_STOP_RXCALLBACK;
rx_WakeupServerProcs();
shutdown_afstest(void)
{
AFS_STATCNT(shutdown_afstest);
- afs_initState = afs_termState = afs_setTime = 0;
+ afs_initState = afs_termState = 0;
AFS_Running = afs_CB_Running = 0;
afs_CacheInit_Done = afs_Go_Done = 0;
if (afs_cold_shutdown) {
git://git.openafs.org / openafs.git / blobdiff