static void
CRTest(char *dname, char *ename, int count)
{
char tbuffer[200];
int i;
afs_int32 fid[3];
dirhandle dir;
int code;
CreateDir(dname, &dir);
memset(fid, 0, sizeof(fid));
afs_dir_MakeDir(&dir, fid, fid);
for (i = 0; i < count; i++) {
sprintf(tbuffer, "%s%d", ename, i);
fid[1] = fidCounter++;
fid[2] = count;
code = afs_dir_Create(&dir, tbuffer, &fid);
if (i % 100 == 0) {
printf("#");
fflush(stdout);
}
if (code) {
printf("code for '%s' is %d\n", tbuffer, code);
return;
}
}
DFlush();
}
static void
DelTest(char *dname, char *ename)
{
dirhandle dir;
int code;
OpenDir(dname, &dir);
code = afs_dir_Delete(&dir, ename);
if (code)
printf("delete code is %d\n", code);
DFlush();
}
static void
AddEntry(char *dname, char *ename)
{
dirhandle dir;
long fid[3];
int code;
fid[1] = fidCounter++;
fid[2] = 3;
OpenDir(dname, &dir);
code = afs_dir_Create(&dir, ename, fid);
if (code)
printf("create code %d\n", code);
DFlush();
}
static void
LookupDir(char *dname, char *ename)
{
dirhandle dir;
long fid[3];
int code;
OpenDir(dname, &dir);
code = afs_dir_Lookup(&dir, ename, fid);
if (code)
printf("lookup code %d\n", code);
else {
printf("Found fid %ld.%ld for file '%s'\n", fid[1], fid[2], ename);
}
DFlush();
}
static void
SalvageDir(char *iname, char *oname)
{
dirhandle in, out;
afs_int32 myFid[3], parentFid[3];
OpenDir(iname, &in);
if (afs_dir_Lookup(&in, ".", myFid) ||
afs_dir_Lookup(&in, "..", parentFid)) {
printf("Lookup of \".\" and/or \"..\" failed: ");
printf("%d %d %d %d\n", myFid[1], myFid[2], parentFid[1],
parentFid[2]);
printf("Directory cannnot be salvaged\n");
}
CreateDir(oname, &out);
DirSalvage(&in, &out, myFid[1], myFid[2], parentFid[1], parentFid[2]);
DFlush();
}
void
shutdown_bufferpackage(void)
{
struct buffer *tp;
int i;
AFS_STATCNT(shutdown_bufferpackage);
/* Free all allocated Buffers and associated buffer pages */
DFlush();
if (afs_cold_shutdown) {
dinit_flag = 0;
tp = Buffers;
for (i = 0; i < nbuffers; i += NPB, tp += NPB) {
afs_osi_Free(tp->data, NPB * AFS_BUFFER_PAGESIZE);
}
afs_osi_Free(Buffers, nbuffers * sizeof(struct buffer));
nbuffers = 0;
timecounter = 1;
for (i = 0; i < PHSIZE; i++)
phTable[i] = 0;
memset(&afs_bufferLock, 0, sizeof(afs_lock_t));
}
}
/* This function always holds the GLOCK whilst it is running. The caller
* gets the GLOCK before invoking it, and afs_osi_Sleep drops the GLOCK
* whilst we are sleeping, and regains it when we're woken up.
*/
void
afs_Daemon(void)
{
afs_int32 code;
struct afs_exporter *exporter;
afs_int32 now;
afs_int32 last3MinCheck, last10MinCheck, last60MinCheck, lastNMinCheck;
afs_int32 last1MinCheck, last5MinCheck;
afs_uint32 lastCBSlotBump;
char cs_warned = 0;
AFS_STATCNT(afs_Daemon);
afs_rootFid.Fid.Volume = 0;
while (afs_initState < 101)
afs_osi_Sleep(&afs_initState);
#ifdef AFS_DARWIN80_ENV
if (afs_osi_ctxtp_initialized)
osi_Panic("vfs context already initialized");
while (afs_osi_ctxtp && vfs_context_ref)
afs_osi_Sleep(&afs_osi_ctxtp);
if (afs_osi_ctxtp && !vfs_context_ref)
vfs_context_rele(afs_osi_ctxtp);
afs_osi_ctxtp = vfs_context_create(NULL);
afs_osi_ctxtp_initialized = 1;
#endif
now = osi_Time();
lastCBSlotBump = now;
/* when a lot of clients are booted simultaneously, they develop
* annoying synchronous VL server bashing behaviors. So we stagger them.
*/
last1MinCheck = now + ((afs_random() & 0x7fffffff) % 60); /* an extra 30 */
last3MinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
last60MinCheck = now - 1800 + ((afs_random() & 0x7fffffff) % 3600);
last10MinCheck = now - 300 + ((afs_random() & 0x7fffffff) % 600);
last5MinCheck = now - 150 + ((afs_random() & 0x7fffffff) % 300);
lastNMinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
/* start off with afs_initState >= 101 (basic init done) */
while (1) {
afs_CheckCallbacks(20); /* unstat anything which will expire soon */
/* things to do every 20 seconds or less - required by protocol spec */
if (afs_nfsexporter)
afs_FlushActiveVcaches(0); /* flush NFS writes */
afs_FlushVCBs(1); /* flush queued callbacks */
afs_MaybeWakeupTruncateDaemon(); /* free cache space if have too */
rx_CheckPackets(); /* Does RX need more packets? */
now = osi_Time();
if (lastCBSlotBump + CBHTSLOTLEN < now) { /* pretty time-dependant */
lastCBSlotBump = now;
if (afs_BumpBase()) {
afs_CheckCallbacks(20); /* unstat anything which will expire soon */
}
}
if (last1MinCheck + 60 < now) {
/* things to do every minute */
DFlush(); /* write out dir buffers */
afs_WriteThroughDSlots(); /* write through cacheinfo entries */
ObtainWriteLock(&afs_xvcache, 736);
afs_FlushReclaimedVcaches();
ReleaseWriteLock(&afs_xvcache);
afs_FlushActiveVcaches(1); /* keep flocks held & flush nfs writes */
#if 0
afs_StoreDirtyVcaches();
#endif
afs_CheckRXEpoch();
last1MinCheck = now;
}
if (last3MinCheck + 180 < now) {
afs_CheckTokenCache(); /* check for access cache resets due to expired
* tickets */
last3MinCheck = now;
}
if (afsd_dynamic_vcaches && (last5MinCheck + 300 < now)) {
/* start with trying to drop us back to our base usage */
int anumber = VCACHE_FREE + (afs_vcount - afs_cacheStats);
if (anumber > 0) {
ObtainWriteLock(&afs_xvcache, 734);
afs_ShakeLooseVCaches(anumber);
ReleaseWriteLock(&afs_xvcache);
}
last5MinCheck = now;
}
if (!afs_CheckServerDaemonStarted) {
/* Do the check here if the correct afsd is not installed. */
if (!cs_warned) {
cs_warned = 1;
afs_warn("Please install afsd with check server daemon.\n");
}
if (lastNMinCheck + afs_probe_interval < now) {
/* only check down servers */
afs_CheckServers(1, NULL);
lastNMinCheck = now;
}
}
if (last10MinCheck + 600 < now) {
#ifdef AFS_USERSPACE_IP_ADDR
extern int rxi_GetcbiInfo(void);
#endif
afs_Trace1(afs_iclSetp, CM_TRACE_PROBEUP, ICL_TYPE_INT32, 600);
#ifdef AFS_USERSPACE_IP_ADDR
if (rxi_GetcbiInfo()) { /* addresses changed from last time */
afs_FlushCBs();
}
#else /* AFS_USERSPACE_IP_ADDR */
if (rxi_GetIFInfo()) { /* addresses changed from last time */
afs_FlushCBs();
}
#endif /* else AFS_USERSPACE_IP_ADDR */
if (!afs_CheckServerDaemonStarted)
afs_CheckServers(0, NULL);
afs_GCUserData(0); /* gc old conns */
/* This is probably the wrong way of doing GC for the various exporters but it will suffice for a while */
for (exporter = root_exported; exporter;
exporter = exporter->exp_next) {
(void)EXP_GC(exporter, 0); /* Generalize params */
}
{
static int cnt = 0;
if (++cnt < 12) {
afs_CheckVolumeNames(AFS_VOLCHECK_EXPIRED |
AFS_VOLCHECK_BUSY);
} else {
cnt = 0;
afs_CheckVolumeNames(AFS_VOLCHECK_EXPIRED |
AFS_VOLCHECK_BUSY |
AFS_VOLCHECK_MTPTS);
}
}
last10MinCheck = now;
}
if (last60MinCheck + 3600 < now) {
afs_Trace1(afs_iclSetp, CM_TRACE_PROBEVOLUME, ICL_TYPE_INT32,
3600);
afs_CheckRootVolume();
#if AFS_GCPAGS
if (afs_gcpags == AFS_GCPAGS_OK) {
afs_int32 didany;
afs_GCPAGs(&didany);
}
#endif
last60MinCheck = now;
}
if (afs_initState < 300) { /* while things ain't rosy */
code = afs_CheckRootVolume();
if (code == 0)
afs_initState = 300; /* succeeded */
if (afs_initState < 200)
afs_initState = 200; /* tried once */
afs_osi_Wakeup(&afs_initState);
}
/* 18285 is because we're trying to divide evenly into 128, that is,
* CBSlotLen, while staying just under 20 seconds. If CBSlotLen
* changes, should probably change this interval, too.
* Some of the preceding actions may take quite some time, so we
* might not want to wait the entire interval */
now = 18285 - (osi_Time() - now);
if (now > 0) {
afs_osi_Wait(now, &AFS_WaitHandler, 0);
}
if (afs_termState == AFSOP_STOP_AFS) {
if (afs_CheckServerDaemonStarted)
afs_termState = AFSOP_STOP_CS;
else
afs_termState = AFSOP_STOP_TRUNCDAEMON;
afs_osi_Wakeup(&afs_termState);
return;
}
}
}