#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
+#include <string.h>
#include <sys/types.h>
#include <afs/procmgmt.h> /* signal(), kill(), wait(), etc. */
#include <sys/stat.h>
#include <netdb.h>
#include <unistd.h> /* sysconf() */
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
-
#ifndef ITIMER_REAL
#include <sys/time.h>
#endif /* ITIMER_REAL */
#ifndef AFS_NT40_ENV
#include <afs/netutils.h>
#endif
+#include "viced_prototypes.h"
#include "viced.h"
#include "host.h"
#ifdef AFS_PTHREAD_ENV
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();
int SawPctSpare;
int debuglevel = 0;
int printBanner = 0;
-int rxJumbograms = 1; /* default is to send and receive jumbograms. */
+int rxJumbograms = 0; /* default is to not send and receive jumbograms. */
int rxBind = 0; /* don't bind */
+int rxkadDisableDotCheck = 0; /* disable check for dot in principal name */
int rxMaxMTU = -1;
afs_int32 implicitAdminRights = PRSFS_LOOKUP; /* The ADMINISTER right is
* already implied */
* certain background threads before we are allowed to dump state to
* disk
*/
+
+#if !defined(PTHREAD_RWLOCK_INITIALIZER) && defined(AFS_DARWIN80_ENV)
+#define PTHREAD_RWLOCK_INITIALIZER {0x2DA8B3B4, {0}}
+#endif
+
struct fs_state fs_state =
{ FS_MODE_NORMAL,
0,
*/
/* DEBUG HACK */
-static int
-CheckDescriptors()
+static void *
+CheckDescriptors(void *unused)
{
#ifndef AFS_NT40_ENV
struct afs_stat status;
for (i = 0; i < tsize; i++) {
if (afs_fstat(i, &status) != -1) {
printf("%d: dev %x, inode %u, length %u, type/mode %x\n", i,
- status.st_dev, status.st_ino, status.st_size,
+ status.st_dev, status.st_ino,
+ (unsigned int) status.st_size,
status.st_mode);
}
}
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
setThreadId("FsyncCheckLWP");
-#ifdef AFS_PTHREAD_ENV
- assert(pthread_cond_init(&fsync_cond, NULL) == 0);
- assert(pthread_mutex_init(&fsync_glock_mutex, NULL) == 0);
-#endif
-
#ifdef AFS_DEMAND_ATTACH_FS
FS_STATE_WRLOCK;
while (fs_state.mode == FS_MODE_NORMAL) {
FS_UNLOCK;
FS_STATE_UNLOCK;
#endif /* AFS_DEMAND_ATTACH_FS */
+ return NULL;
}
/*------------------------------------------------------------------------
-static int
-CheckSignal()
+static void *
+CheckSignal(void *unused)
{
if (FS_registered > 0) {
/*
}
}
+ if (dopanic)
+ assert(0);
+
exit(0);
}
-int
-ShutDown(void)
+void *
+ShutDown(void *unused)
{ /* backward compatibility */
ShutDownAndCore(DONTPANIC);
return 0;
fputs("[-rxdbge (enable rxevent debugging)] ", stdout);
fputs("[-rxmaxmtu <bytes>] ", stdout);
fputs("[-rxbind (bind the Rx socket to one address)] ", stdout);
+ fputs("[-allow-dotted-principals (disable the rxkad principal name dot check)] ", stdout);
#ifdef AFS_DEMAND_ATTACH_FS
fputs("[-fs-state-dont-save (disable state save during shutdown)] ", stdout);
fputs("[-fs-state-dont-restore (disable state restore during startup)] ", stdout);
fputs("[-udpsize <size of socket buffer in bytes>] ", stdout);
fputs("[-sendsize <size of send buffer in bytes>] ", stdout);
fputs("[-abortthreshold <abort threshold>] ", stdout);
+ fputs("[-nojumbo (disable jumbogram network packets - deprecated)] ", stdout);
+ fputs("[-jumbo (enable jumbogram network packets)] ", stdout);
/* fputs("[-enable_peer_stats] ", stdout); */
/* fputs("[-enable_process_stats] ", stdout); */
fputs("[-help]\n", stdout);
#endif
else if (!strcmp(argv[i], "-nojumbo")) {
rxJumbograms = 0;
+ } else if (!strcmp(argv[i], "-jumbo")) {
+ rxJumbograms = 1;
} else if (!strcmp(argv[i], "-rxbind")) {
rxBind = 1;
+ } else if (!strcmp(argv[i], "-allow-dotted-principals")) {
+ rxkadDisableDotCheck = 1;
} else if (!strcmp(argv[i], "-rxmaxmtu")) {
if ((i + 1) >= argc) {
fprintf(stderr, "missing argument for -rxmaxmtu\n");
if (!Sawcbs)
numberofcbs = 64000;
if (!Sawlwps)
- lwps = 12;
+ lwps = 128;
if (!Sawbufs)
buffs = 120;
if (!SawVC)
extern int rxi_numNetAddrs;
extern afs_uint32 rxi_NetAddrs[];
-#ifndef AFS_NT40_ENV
if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || AFSDIR_SERVER_NETINFO_FILEPATH) {
/*
* Find addresses we are supposed to register as per the netrestrict
}
FS_HostAddr_cnt = (afs_uint32) code;
} else
-#endif
{
FS_HostAddr_cnt = rx_getAllAddr(FS_HostAddrs, ADDRSPERSITE);
}
rx_SetBusyThreshold(busy_threshold, VBUSY);
rx_SetCallAbortThreshold(abort_threshold);
rx_SetConnAbortThreshold(abort_threshold);
+#ifdef AFS_XBSD_ENV
+ stackSize = 128 * 1024;
+#else
stackSize = lwps * 4000;
if (stackSize < 32000)
stackSize = 32000;
else if (stackSize > 44000)
stackSize = 44000;
-#if defined(AFS_HPUX_ENV) || defined(AFS_SUN_ENV) || defined(AFS_SGI51_ENV)
+#endif
+#if defined(AFS_HPUX_ENV) || defined(AFS_SUN_ENV) || defined(AFS_SGI51_ENV) || defined(AFS_XBSD_ENV)
rx_SetStackSize(1, stackSize);
#endif
if (udpBufSize)
("Failed to initialize RX, probably two servers running.\n"));
exit(-1);
}
+ if (rxkadDisableDotCheck) {
+ rx_SetSecurityConfiguration(tservice, RXS_CONFIG_FLAGS,
+ (void *)RXS_CONFIG_FLAGS_DISABLE_DOTCHECK);
+ }
rx_SetMinProcs(tservice, 3);
rx_SetMaxProcs(tservice, lwps);
rx_SetCheckReach(tservice, 1);
+ rx_SetServerIdleDeadErr(tservice, VNOSERVICE);
tservice =
rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", sc, 4,
/* allow super users to manage RX statistics */
rx_SetRxStatUserOk(fs_rxstat_userok);
+#ifdef AFS_PTHREAD_ENV
+ assert(pthread_cond_init(&fsync_cond, NULL) == 0);
+ assert(pthread_mutex_init(&fsync_glock_mutex, NULL) == 0);
+#endif
+
+#if !defined(AFS_DEMAND_ATTACH_FS)
+ /*
+ * For DAFS, we do not start the Rx server threads until after
+ * the volume package is initialized, and fileserver state is
+ * restored. This is necessary in order to keep host and callback
+ * package state pristine until we have a chance to restore state.
+ *
+ * Furthermore, startup latency is much lower with dafs, so this
+ * shouldn't pose a serious problem.
+ */
rx_StartServer(0); /* now start handling requests */
+#endif
/* we ensure that there is enough space in the vnode buffer to satisfy
** requests from all concurrent threads.
* restore fileserver state */
fs_stateRestore();
}
+ rx_StartServer(0); /* now start handling requests */
#endif /* AFS_DEMAND_ATTACH_FS */
/*
#ifdef AFS_PTHREAD_ENV
ViceLog(5, ("Starting pthreads\n"));
+#ifdef AFS_DEMAND_ATTACH_FS
FS_STATE_INIT;
+#endif
assert(pthread_attr_init(&tattr) == 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
#else /* AFS_PTHREAD_ENV */
assert(LWP_WaitProcess(&parentPid) == LWP_SUCCESS);
#endif /* AFS_PTHREAD_ENV */
+ return 0;
}