able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/svcimgs/ntrepl/main/main.c

2371 lines
60 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
main.c
Abstract:
This is the main thread for the File Replication Service.
Author:
Billy J. Fuller 20-Mar-1997
Environment
User mode winnt
--*/
#include <ntreppch.h>
#pragma hdrstop
#include <frs.h>
#include <tablefcn.h>
#include <perrepsr.h>
#define INITGUID
#include "frstrace.h"
PCHAR LatestChanges[] = {
"Latest changes:",
"Whistler Beta-2",
NULL
};
/*++
" RC3-Q1: 432553, 436070, 432549",
" WMI Perf Tracing",
" Allow all junction points",
" Automatic trigger of non-auth restore on WRAP_ERROR",
" Allow changing replica root path",
" 03/18/00 - sudarc - checkin",
" 03/15/00 - 32/64 Comm fix.",
" 03/20 - merge with sudarc.",
" 03/30/00 - sudarc - checkin - volatile connection cleanup.",
" 04/14/00 - sudarc - checkin - bugbug, memleak, and poll summary eventlog.",
" 04/28/00 - davidor - 32-64 interop, CO mem leak, stage hdr & Comm pkt cmpres guid, misc.",
" - remove old disk cache check, disable most closewithusndampening calls.",
" - cxtion lock cleanup, bugbug removal, add retire check table.",
" 05/04/00 - sudarc - checkin - compression of staging files.",
" 07/17/00 - sudarc - checkin - (120495, 126578, 126635, 107760, 54527, 6675, 145265).",
" 07/20/00 - sudarc - checkin - (145264, 145947).",
" 08/18/00 - sudarc - checkin - (154749, 150407, 161651).",
" 08/00 - davidor - error cleanup, restart after resource triggered shutdown",
" - add tracking records :T: and set log sev level to 2",
" 08/30/00 - sudarc - checkin - (17640, 52732, 53459, 120508, 138742, 159846, 164114, 164318, 169041).",
" 09/05/00 - davidor - 10312, 71447 avoid staging area filling by dup suppression",
--*/
HANDLE ShutDownEvent;
HANDLE ShutDownComplete;
HANDLE DataBaseEvent;
HANDLE JournalEvent;
HANDLE ChgOrdEvent;
HANDLE ReplicaEvent;
HANDLE CommEvent;
HANDLE DsPollEvent;
HANDLE DsShutDownComplete;
PWCHAR ServerPrincName;
BOOL IsAMember = FALSE;
BOOL IsADc = FALSE;
BOOL IsAPrimaryDc = FALSE;
BOOL EventLogIsRunning = FALSE;
BOOL RpcssIsRunning = FALSE;
BOOL RunningAsAService = TRUE;
BOOL NoDs = FALSE;
BOOL FrsIsShuttingDown = FALSE;
BOOL FrsScmRequestedShutdown = FALSE;
BOOL FrsIsAsserting = FALSE;
//
// Require mutual authentication
//
BOOL MutualAuthenticationIsEnabled;
//
// Directory and file filter lists from registry.
//
PWCHAR RegistryFileExclFilterList;
PWCHAR RegistryFileInclFilterList;
PWCHAR RegistryDirExclFilterList;
PWCHAR RegistryDirInclFilterList;
//
// Synchronize the shutdown thread with the service controller
//
CRITICAL_SECTION ServiceLock;
//
// Synchronize initialization
//
CRITICAL_SECTION MainInitLock;
//
// Convert the ANSI ArgV into a UNICODE ArgV
//
PWCHAR *WideArgV;
//
// Process Handle
//
HANDLE ProcessHandle;
//
// Working path / DB Log path
//
PWCHAR WorkingPath;
PWCHAR DbLogPath;
//
// Database directories (UNICODE and ASCII)
//
PWCHAR JetPath;
PWCHAR JetFile;
PWCHAR JetFileCompact;
PWCHAR JetSys;
PWCHAR JetTemp;
PWCHAR JetLog;
PCHAR JetPathA;
PCHAR JetFileA;
PCHAR JetFileCompactA;
PCHAR JetSysA;
PCHAR JetTempA;
PCHAR JetLogA;
//
// Limit the amount of staging area used (in kilobytes). This is
// a soft limit, the actual usage may be higher.
//
DWORD StagingLimitInKb;
//
// Default staging limit in kb to be assigned to a new staging area.
//
DWORD DefaultStagingLimitInKb;
//
// Max number replica sets and Jet Sessions allowed.
//
ULONG MaxNumberReplicaSets;
ULONG MaxNumberJetSessions;
//
// Maximum number of outbound changeorders allowed outstanding per connection.
//
ULONG MaxOutLogCoQuota;
//
// If TRUE then try to preserve existing file OIDs whenever possible.
// -- See Bug 352250 for why this is a risky thing to do.
//
BOOL PreserveFileOID;
//
// Major/minor (see frs.h)
//
ULONG NtFrsMajor = NTFRS_MAJOR;
ULONG NtFrsMinor = NTFRS_MINOR;
ULONG NtFrsStageMajor = NTFRS_STAGE_MAJOR;
ULONG NtFrsStageMinor = NTFRS_STAGE_MINOR_2;
ULONG NtFrsCommMinor = NTFRS_COMM_MINOR_4;
PCHAR NtFrsModule = __FILE__;
PCHAR NtFrsDate = __DATE__;
PCHAR NtFrsTime = __TIME__;
//
// Shutdown timeout
//
ULONG ShutDownTimeOut = DEFAULT_SHUTDOWN_TIMEOUT;
//
// A useful thing to have around
//
WCHAR ComputerName[MAX_COMPUTERNAME_LENGTH + 2];
PWCHAR ComputerDnsName;
PWCHAR ServiceLongName;
//
// The rpc server may reference this table as soon as the rpc interface
// is registered. Make sure it is setup.
//
extern PGEN_TABLE ReplicasByGuid;
//
// The staging area table is references early in the startup process
//
extern PGEN_TABLE StagingAreaTable;
PGEN_TABLE CompressionTable;
//
// Size of buffer to use when enumerating directories. Actual memory
// usage will be #levels * SizeOfBuffer.
//
LONG EnumerateDirectorySizeInBytes;
BOOL MainInitHasRun;
//
// Do not accept stop control unless the service is in SERVICE_RUNNING state.
// This prevents the service from getting confused when a stop is called
// while the service is starting.
//
SERVICE_STATUS ServiceStatus = {
SERVICE_WIN32_OWN_PROCESS,
SERVICE_START_PENDING,
// SERVICE_ACCEPT_STOP |
// SERVICE_ACCEPT_PAUSE_CONTINUE |
SERVICE_ACCEPT_SHUTDOWN,
0,
0,
0,
60*1000
};
//
// Supported compression formats.
//
//
// This is the compression format for uncompressed data.
//
DEFINE_GUID ( /* 00000000-0000-0000-0000-000000000000 */
FrsGuidCompressionFormatNone,
0x00000000,
0x0000,
0x0000,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
);
//
// This is the compression format for data compressed using NTFS's LZNT1 compression
// routines.
//
DEFINE_GUID ( /* 64d2f7d2-2695-436d-8830-8d3c58701e15 */
FrsGuidCompressionFormatLZNT1,
0x64d2f7d2,
0x2695,
0x436d,
0x88, 0x30, 0x8d, 0x3c, 0x58, 0x70, 0x1e, 0x15
);
//
// Fixed guid for the dummy cxtion (aka GhostCxtion) assigned to orphan remote
// change orders whose inbound cxtion has been deleted from the DS but they
// have already past the fetching state and can finish without the real cxtion
// coming back. No authentication checks are made for this dummy cxtion.
//
DEFINE_GUID ( /* b9d307a7-a140-4405-991e-281033f03309 */
FrsGuidGhostCxtion,
0xb9d307a7,
0xa140,
0x4405,
0x99, 0x1e, 0x28, 0x10, 0x33, 0xf0, 0x33, 0x09
);
DEFINE_GUID ( /* 3fe2820f-3045-4932-97fe-00d10b746dbf */
FrsGhostJoinGuid,
0x3fe2820f,
0x3045,
0x4932,
0x97, 0xfe, 0x00, 0xd1, 0x0b, 0x74, 0x6d, 0xbf
);
//
// Static Ghost cxtion structure. This cxtion is assigned to orphan remote change
// orders in the inbound log whose cxtion is deleted from the DS but who have already
// past the fetching state and do not need the cxtion to complete processing. No
// authentication checks are made for this dummy cxtion.
//
PCXTION FrsGhostCxtion;
SERVICE_STATUS_HANDLE ServiceStatusHandle = NULL;
VOID
InitializeEventLog(
VOID
);
DWORD
FrsSetServiceFailureAction(
VOID
);
VOID
FrsRpcInitializeAccessChecks(
VOID
);
BOOL
FrsSetupPrivileges (
VOID
);
VOID
CfgRegAdjustTuningDefaults(
VOID
);
VOID
CommInitializeCommSubsystem(
VOID
);
VOID
SndCsInitialize(
VOID
);
VOID
SndCsUnInitialize(
VOID
);
VOID
SndCsShutDown(
VOID
);
VOID
DbgPrintAllStats(
VOID
);
// FRS Capacity Planning
//
#define RESOURCE_NAME L"MofResourceName"
#define IMAGE_PATH L"ntfrs.exe"
DWORD FrsWmiEventTraceFlag = FALSE;
TRACEHANDLE FrsWmiTraceRegistrationHandle = (TRACEHANDLE) 0;
TRACEHANDLE FrsWmiTraceLoggerHandle = (TRACEHANDLE) 0;
// This is the FRS control Guid for the group of Guids traced below
//
DEFINE_GUID ( /* 78a8f0b1-290e-4c4c-9720-c7f1ef68ce21 */
FrsControlGuid,
0x78a8f0b1,
0x290e,
0x4c4c,
0x97, 0x20, 0xc7, 0xf1, 0xef, 0x68, 0xce, 0x21
);
// Traceable Guids start here
//
DEFINE_GUID ( /* 2eee6bbf-6665-44cf-8ed7-ceea1d306085 */
FrsTransGuid,
0x2eee6bbf,
0x6665,
0x44cf,
0x8e, 0xd7, 0xce, 0xea, 0x1d, 0x30, 0x60, 0x85
);
TRACE_GUID_REGISTRATION FrsTraceGuids[] =
{
{ & FrsTransGuid, NULL }
};
#define FrsGuidCount (sizeof(FrsTraceGuids) / sizeof(TRACE_GUID_REGISTRATION))
//
// Trace initialization / shutdown routines
//
ULONG
FrsWmiTraceControlCallback(
IN WMIDPREQUESTCODE RequestCode,
IN PVOID RequestContext,
IN OUT ULONG * InOutBufferSize,
IN OUT PVOID Buffer
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
#undef DEBSUB
#define DEBSUB "FrsWmiTraceControlCallback:"
PWNODE_HEADER Wnode = (PWNODE_HEADER) Buffer;
ULONG Status;
ULONG RetSize;
Status = ERROR_SUCCESS;
switch (RequestCode) {
case WMI_ENABLE_EVENTS:
FrsWmiTraceLoggerHandle = GetTraceLoggerHandle(Buffer);
FrsWmiEventTraceFlag = TRUE;
RetSize = 0;
DPRINT1(0, "FrsTraceContextCallback(WMI_ENABLE_EVENTS,0x%08X)\n",
FrsWmiTraceLoggerHandle);
break;
case WMI_DISABLE_EVENTS:
FrsWmiTraceLoggerHandle = (TRACEHANDLE) 0;
FrsWmiEventTraceFlag = FALSE;
RetSize = 0;
DPRINT(0, "FrsWmiTraceContextCallback(WMI_DISABLE_EVENTS)\n");
break;
default:
RetSize = 0;
Status = ERROR_INVALID_PARAMETER;
break;
}
*InOutBufferSize = RetSize;
return Status;
}
ULONG
FrsWmiInitializeTrace(
VOID
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
#undef DEBSUB
#define DEBSUB "FrsWmiInitializeTrace:"
ULONG WStatus;
HMODULE hModule;
WCHAR FileName[MAX_PATH + 1];
DWORD nLen = 0;
hModule = GetModuleHandleW(IMAGE_PATH);
if (hModule != NULL) {
nLen = GetModuleFileNameW(hModule, FileName, MAX_PATH);
}
if (nLen == 0) {
wcscpy(FileName, IMAGE_PATH);
}
WStatus = RegisterTraceGuidsW(
FrsWmiTraceControlCallback,
NULL,
& FrsControlGuid,
FrsGuidCount,
FrsTraceGuids,
FileName,
RESOURCE_NAME,
& FrsWmiTraceRegistrationHandle);
if (!WIN_SUCCESS(WStatus)) {
DPRINT4(0, "NTFRS: FrsWmiInitializeTrace(%ws,%ws,%d) returns 0x%08X\n",
FileName, RESOURCE_NAME, FrsGuidCount, WStatus);
}
return WStatus;
}
ULONG
FrsWmiShutdownTrace(
void
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
#undef DEBSUB
#define DEBSUB "FrsWmiShutdownTrace:"
ULONG WStatus = ERROR_SUCCESS;
UnregisterTraceGuids(FrsWmiTraceRegistrationHandle);
return WStatus;
}
VOID
FrsWmiTraceEvent(
IN DWORD WmiEventType,
IN DWORD TraceGuid,
IN DWORD rtnStatus
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
#undef DEBSUB
#define DEBSUB "FrsWmiTraceEvent:"
struct {
EVENT_TRACE_HEADER TraceHeader;
DWORD Data;
} Wnode;
DWORD WStatus;
if (FrsWmiEventTraceFlag) {
ZeroMemory(&Wnode, sizeof(Wnode));
//
// Set WMI event type
//
Wnode.TraceHeader.Class.Type = (UCHAR) WmiEventType;
Wnode.TraceHeader.GuidPtr = (ULONGLONG) FrsTraceGuids[TraceGuid].Guid;
Wnode.TraceHeader.Size = sizeof(Wnode);
Wnode.TraceHeader.Flags = WNODE_FLAG_TRACED_GUID | WNODE_FLAG_USE_GUID_PTR;
WStatus = TraceEvent(FrsWmiTraceLoggerHandle, (PEVENT_TRACE_HEADER) &Wnode);
if (!WIN_SUCCESS(WStatus)) {
DPRINT5(0, "FreWmiTraceEvent(%d,%d,%d) = %d,0x%08X\n",
WmiEventType, TraceGuid, rtnStatus, WStatus, WStatus);
}
}
}
BOOL
WINAPI
MainSigHandler(
IN DWORD Signal
)
/*++
Routine Description:
Handle CTRL_BREAK_EVENT and CTRL_C_EVENT by setting the shutdown event.
Arguments:
Signal - signal received.
Return Value:
Set the ShutDownEvent and return TRUE.
--*/
{
#undef DEBSUB
#define DEBSUB "MainSigHandler:"
//
// ShutDown on signal CTRL_C_EVENT or CTRL_BREAK_EVENT
//
if ((Signal == CTRL_C_EVENT) || (Signal == CTRL_BREAK_EVENT)) {
DPRINT1(0,":S: Signal %s received, shutting down now...\n",
(Signal == CTRL_C_EVENT) ? "CTRL_C_EVENT" : "CTRL_BREAK_EVENT");
FrsScmRequestedShutdown = TRUE;
FrsIsShuttingDown = TRUE;
SetEvent(ShutDownEvent);
return TRUE;
}
DPRINT1(0,":S: Signal %d received, not handled\n", Signal);
return FALSE;
}
ULONG
MainSCCheckPointUpdate(
IN PVOID pCurrentState
)
/*++
Routine Description:
This thread repeatedly calls the Service Controller to update
the checkpoint and reset the timeout value so that the
service controller does not time out waiting for a response.
When called in shutdown path the thread exits after a waiting
a max "ShutDownTimeOut" # of seconds. All the subsystems might
not have shutdown cleanly by this time but we don't want to take
for ever to shutdown. This value is picked up from the registry.
Arguments:
pCurrentState - Pointer to the value of the current state of
the service. Depending on this value the
function either waits to shutdown or startup.
Return Value:
Exits with STATUS_UNSUCCESSFUL
--*/
{
#undef DEBSUB
#define DEBSUB "MainSCCheckPointUpdate:"
ULONG Timeout = ShutDownTimeOut;
DWORD CheckPoint = 1;
DWORD WStatus = ERROR_SUCCESS;
DWORD Ret = 0;
if (pCurrentState && *(DWORD *)pCurrentState == SERVICE_STOP_PENDING) {
//
// Thread is called in the shutdown path to make sure that FRS exits
//
while (Timeout) {
DPRINT2(0, ":S: EXIT COUNTDOWN AT T-%d CheckPoint = %x\n", Timeout, CheckPoint);
DEBUG_FLUSH();
if (Timeout < 5) {
Sleep(Timeout * 1000);
Timeout = 0;
} else {
Sleep(5 * 1000);
//
// Update the status every 5 seconds to get the new checkpoint.
//
WStatus = FrsSetServiceStatus(SERVICE_STOP_PENDING, CheckPoint, (ShutDownTimeOut + 5) *1000, NO_ERROR);
if (!WIN_SUCCESS(WStatus)) {
//
// Unable to set the service status. Exit process anyways.
//
break;
}
CheckPoint++;
Timeout -= 5;
}
}
DPRINT(0, ":S: EXIT COUNTDOWN EXPIRED\n");
DEBUG_FLUSH();
EPRINT0(EVENT_FRS_STOPPED_FORCE);
//
// EXIT FOR RESTART
//
// If we are shutting down after taking an assert then don't set the
// service state to stopped. This will cause the service controller to
// restart us if the recorvery option is set. In case of a service controller
// initiated shutwon we want to set the state to stopped so that it does not
// restart us.
//
if (!FrsIsAsserting && FrsScmRequestedShutdown) {
FrsSetServiceStatus(SERVICE_STOPPED, CheckPoint, ShutDownTimeOut*1000, NO_ERROR);
}
ExitProcess(ERROR_NO_SYSTEM_RESOURCES);
FrsFree(pCurrentState);
return ERROR_NO_SYSTEM_RESOURCES;
} else if (pCurrentState && *(DWORD *)pCurrentState == SERVICE_START_PENDING){
//
// Thread is called in the startup path to make sure that
// service controller does not timeout waiting for the
// service to start up.
//
while (TRUE) {
DPRINT1(0, ":S: STARTUP CheckPoint = %x\n",CheckPoint);
Sleep(5 * 1000);
EnterCriticalSection(&ServiceLock);
if (ServiceStatus.dwCurrentState == SERVICE_START_PENDING
&& !FrsIsShuttingDown) {
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwCheckPoint = CheckPoint;
ServiceStatus.dwWaitHint = DEFAULT_STARTUP_TIMEOUT * 1000;
ServiceStatus.dwWin32ExitCode = NO_ERROR;
//
// Update the status every 5 seconds to get the new checkpoint.
//
Ret = SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
CheckPoint++;
if (!Ret) {
//
// Can not set service status. Let the service try to start up
// in the given time. If it does not then the service controller
// time out and stop it.
//
LeaveCriticalSection(&ServiceLock);
break;
}
} else {
//
// Service has either already started or it has moved to another state.
//
LeaveCriticalSection(&ServiceLock);
break;
}
LeaveCriticalSection(&ServiceLock);
}
}
FrsFree(pCurrentState);
return ERROR_SUCCESS;
}
VOID
MainStartShutDown(
VOID
)
/*++
Routine Description:
Shutdown what we can.
Arguments:
None.
Return Value:
None.
--*/
{
#undef DEBSUB
#define DEBSUB "MainStartShutDown:"
ULONGLONG SecondsRunning;
DPRINT(0, ":S: SHUTDOWN IN PROGRESS...\n");
DEBUG_FLUSH();
//
// Do not restart if it was a service control manager requested shutdown.
//
DebugInfo.Restart = FALSE;
if (!FrsScmRequestedShutdown) {
GetSystemTimeAsFileTime((FILETIME *)&SecondsRunning);
SecondsRunning /= (10 * 1000 * 1000);
SecondsRunning -= DebugInfo.StartSeconds;
//
// Restart the service if it was an FRS triggered shutdown, e.g. malloc
// failed or thread create failed, etc.
// Also restart the service after an assertion failure iff the
// service was able to run for some minutes.
//
// Assertion failures during shutdown won't trigger a restart since this
// test is made before shutdown starts.
//
DebugInfo.Restart = !FrsIsAsserting ||
(FrsIsAsserting &&
(DebugInfo.RestartSeconds != 0) &&
(SecondsRunning >= DebugInfo.RestartSeconds));
}
if (DebugInfo.Restart) {
DPRINT(0, ":S: Restart enabled\n");
} else {
DPRINT(0, ":S: Restart disabled\n");
}
}
VOID
MainShutDownComplete(
VOID
)
/*++
Routine Description:
Kick off the exe that will restart the service after a bit
Arguments:
None.
Return Value:
None.
--*/
{
#undef DEBSUB
#define DEBSUB "MainShutDownComplete:"
STARTUPINFO StartUpInfo;
PROCESS_INFORMATION ProcessInformation;
//
// Done with this service
//
DbgPrintAllStats();
//
// Spawn a new exe if needed
//
if (!RunningAsAService && DebugInfo.Restart) {
GetStartupInfo(&StartUpInfo);
if (!CreateProcess(NULL,
DebugInfo.CommandLine,
NULL,
NULL,
FALSE,
0, // CREATE_NEW_CONSOLE,
NULL,
NULL,
&StartUpInfo,
&ProcessInformation)) {
DPRINT1_WS(0, ":S: ERROR - Spawning %ws :",
DebugInfo.CommandLine, GetLastError());
} else {
DPRINT1(0, ":S: Spawned %ws\n", DebugInfo.CommandLine);
}
}
DPRINT(0,":S: SHUTDOWN COMPLETE\n");
DEBUG_FLUSH();
//
// EXIT FOR RESTART
//
// If restart is desired then simply exit without setting our
// status to SERVICE_STOPPED. The service controller will execute
// our recovery settings which are defaulted to "restart after a
// minute." The exe was restarted above.
//
if (DebugInfo.Restart) {
ExitProcess(ERROR_NO_SYSTEM_RESOURCES);
}
}
ULONG
MainFrsShutDown(
IN PVOID Ignored
)
/*++
Routine Description:
Shutdown the service
Arguments:
Ignored
Return Value:
ERROR_SUCCESS
--*/
{
#undef DEBSUB
#define DEBSUB "MainFrsShutDown:"
DWORD WStatus;
DWORD WaitStatus;
HANDLE ExitThreadHandle;
DWORD ExitThreadId;
PVOID ReplicaKey;
PVOID CxtionKey;
PREPLICA Replica;
PCXTION Cxtion;
DWORD CheckUnjoin;
DWORD LastCheckUnjoin;
DWORD ActiveCoCount, LastCheckActiveCoCount;
PDWORD ServiceWaitState = NULL;
//
// How long is shutdown allowed to take?
//
CfgRegReadDWord(FKC_SHUTDOWN_TIMEOUT, NULL, 0, &ShutDownTimeOut);
DPRINT1(1,":S: Using %d as ShutDownTimeOut\n", ShutDownTimeOut);
//
// Wait for a shutdown event
//
do {
//
// If present, flush the log file every 30 seconds
//
if (DebugInfo.LogFILE) {
WaitStatus = WaitForSingleObject(ShutDownEvent, (30 * 1000));
} else {
WaitStatus = WaitForSingleObject(ShutDownEvent, INFINITE);
}
DEBUG_FLUSH();
} while (WaitStatus == WAIT_TIMEOUT);
FrsIsShuttingDown = TRUE;
EPRINT0(EVENT_FRS_STOPPING);
//
// How long is shutdown allowed to take? Re-read so longer time can
// be used for debug dumping when necc.
//
CfgRegReadDWord(FKC_SHUTDOWN_TIMEOUT, NULL, 0, &ShutDownTimeOut);
DPRINT1(1,":S: Using %d as ShutDownTimeOut\n", ShutDownTimeOut);
//
// SHUTDOWN
//
MainStartShutDown();
//
// Inform the service controller that we are stopping.
//
// Unless we aren't running as a service, or are
// are running to restart the service, or simply running
// as an exe.
//
if (!FrsIsAsserting) {
FrsSetServiceStatus(SERVICE_STOP_PENDING, 0, ShutDownTimeOut*1000, NO_ERROR);
}
//
// Kick off a thread that exits in a bit
// Allocate memory for data to be passed to another thread.
//
ServiceWaitState = FrsAlloc(sizeof(DWORD));
*ServiceWaitState = SERVICE_STOP_PENDING;
ExitThreadHandle = (HANDLE)CreateThread(NULL,
10000,
MainSCCheckPointUpdate,
ServiceWaitState,
0,
&ExitThreadId);
if (!HANDLE_IS_VALID(ExitThreadHandle)) {
ExitProcess(ERROR_NO_SYSTEM_RESOURCES);
}
//
// Minimal shutdown - only the ds polling thread
//
if (!MainInitHasRun) {
DPRINT(1,":S: \tFast shutdown in progress...\n");
//
// ShutDown rpc
//
DPRINT(1,":S: \tShutting down RPC Server...\n");
ShutDownRpc();
DEBUG_FLUSH();
//
// Ask all the threads to exit
//
DPRINT(1,":S: \tShutting down all the threads...\n");
WStatus = ThSupExitThreadGroup(NULL);
DEBUG_FLUSH();
//
// Free the rpc table and princname
//
DPRINT(1,":S: \tFreeing rpc memory...\n");
FrsRpcUnInitialize();
DEBUG_FLUSH();
goto SHUTDOWN_COMPLETE;
}
//
// ShutDown the delayed command server; don't let change orders
// sit on the various retry queues.
//
DPRINT(1,":S: \tShutting down Delayed Server...\n");
ShutDownDelCs();
DEBUG_FLUSH();
//
// ShutDown the staging file generator
//
DPRINT(1,":S: \tShutting down Staging File Generator...\n");
ShutDownStageCs();
DEBUG_FLUSH();
//
// ShutDown the staging file fetcher
//
DPRINT(1,":S: \tShutting down Staging File Fetch...\n");
ShutDownFetchCs();
DEBUG_FLUSH();
//
// ShutDown the initial sync controller
//
DPRINT(1,":S: \tShutting down Initial Sync Controller...\n");
ShutDownInitSyncCs();
DEBUG_FLUSH();
//
// ShutDown the staging file installer
//
DPRINT(1,":S: \tShutting down Staging File Install...\n");
ShutDownInstallCs();
DEBUG_FLUSH();
//
// Stop local change orders.
//
// Shutdown can be delayed indefinitely if the journal cs continues
// to add local change orders to the change order accept queue.
//
// The remote change orders were stopped by setting FrsIsShuttingDown
// to TRUE above.
//
ReplicaKey = NULL;
while (Replica = GTabNextDatum(ReplicasByGuid, &ReplicaKey)) {
DPRINT1(4, ":S: Pause journaling on replica %ws\n", Replica->ReplicaName->Name);
if (Replica->pVme) {
JrnlPauseVolume(Replica->pVme, 5000);
}
}
//
// Shutdown the replicas cleanly.
//
// WARN: all of the change orders have to be taken through the retry
// path before shutting down the rest of the system. Otherwise,
// access violations occur in ChgOrdIssueCleanup(). Perhaps we
// should fix ChgOrdIssueCleanup() to handle the case when
// change order accept has exited and cleaned up its tables?
//
CheckUnjoin = 0;
ReplicaKey = NULL;
while (Replica = GTabNextDatum(ReplicasByGuid, &ReplicaKey)) {
LOCK_CXTION_TABLE(Replica);
CxtionKey = NULL;
while (Cxtion = GTabNextDatum(Replica->Cxtions, &CxtionKey)) {
if (CxtionStateIs(Cxtion, CxtionStateUnjoined) ||
CxtionStateIs(Cxtion, CxtionStateDeleted)) {
DPRINT3(0, ":S: %ws\\%ws %s: Unjoin not needed.\n",
Replica->MemberName->Name, Cxtion->Name->Name,
(Cxtion->Inbound) ? "<-" : "->");
} else {
DPRINT4(0, ":S: %ws\\%ws %s: Unjoin (%d cos).\n",
Replica->MemberName->Name, Cxtion->Name->Name,
(Cxtion->Inbound) ? "<-" : "->", Cxtion->ChangeOrderCount);
RcsSubmitReplicaCxtion(Replica, Cxtion, CMD_UNJOIN);
CheckUnjoin += Cxtion->ChangeOrderCount + 1;
}
}
UNLOCK_CXTION_TABLE(Replica);
}
LastCheckUnjoin = 0;
while (CheckUnjoin && CheckUnjoin != LastCheckUnjoin) {
//
// Wait a bit and check again
//
Sleep(5 * 1000);
LastCheckUnjoin = CheckUnjoin;
CheckUnjoin = 0;
ReplicaKey = NULL;
while (Replica = GTabNextDatum(ReplicasByGuid, &ReplicaKey)) {
LOCK_CXTION_TABLE(Replica);
CxtionKey = NULL;
while (Cxtion = GTabNextDatum(Replica->Cxtions, &CxtionKey)) {
if (CxtionStateIs(Cxtion, CxtionStateUnjoined) ||
CxtionStateIs(Cxtion, CxtionStateDeleted)) {
DPRINT3(0, ":S: %ws\\%ws %s: Unjoin successful.\n",
Replica->MemberName->Name, Cxtion->Name->Name,
(Cxtion->Inbound) ? "<-" : "->");
} else if (Cxtion->ChangeOrderCount) {
DPRINT4(0, ":S: %ws\\%ws %s: Unjoining (%d cos).\n",
Replica->MemberName->Name, Cxtion->Name->Name,
(Cxtion->Inbound) ? "<-" : "->",
Cxtion->ChangeOrderCount);
CheckUnjoin += Cxtion->ChangeOrderCount + 1;
} else {
DPRINT4(0, ":S: %ws\\%ws %s: Ignoring (state %d).\n",
Replica->MemberName->Name, Cxtion->Name->Name,
(Cxtion->Inbound) ? "<-" : "->", GetCxtionState(Cxtion));
}
}
UNLOCK_CXTION_TABLE(Replica);
}
}
if (CheckUnjoin) {
DPRINT(0, "ERROR - Could not unjoin all cxtions.\n");
}
//
// Now wait until any remaining local Change Orders wind through
// retire or retry for each replica set.
//
ReplicaKey = NULL;
while (Replica = GTabNextDatum(ReplicasByGuid, &ReplicaKey)) {
ActiveCoCount = 0;
LastCheckActiveCoCount = 1;
while (ActiveCoCount != LastCheckActiveCoCount) {
LastCheckActiveCoCount = ActiveCoCount;
if ((Replica->pVme != NULL) &&
(Replica->pVme->ActiveInboundChangeOrderTable != NULL)) {
ActiveCoCount = GhtCountEntries(Replica->pVme->ActiveInboundChangeOrderTable);
if (ActiveCoCount == 0) {
break;
}
DPRINT2(0, ":S: Waiting for %d active inbound change orders to finish up for %ws.\n",
ActiveCoCount, Replica->MemberName->Name);
Sleep(5*1000);
}
}
if (ActiveCoCount != 0) {
DPRINT2(0, ":S: ERROR - %d active inbound change orders were not cleaned up for %ws.\n",
ActiveCoCount, Replica->MemberName->Name);
} else {
DPRINT1(0, ":S: All active inbound change orders finished for %ws.\n",
Replica->MemberName->Name);
}
}
//
// ShutDown the replica control command server
//
DPRINT(1,":S: \tShutting down Replica Server...\n");
RcsShutDownReplicaCmdServer();
DEBUG_FLUSH();
//
// ShutDown the send command server
//
DPRINT(1,":S: \tShutting down Comm Server...\n");
SndCsShutDown();
DEBUG_FLUSH();
//
// ShutDown rpc
//
DPRINT(1,":S: \tShutting down RPC Server...\n");
ShutDownRpc();
DEBUG_FLUSH();
//
// ShutDown the waitable timer server
//
DPRINT(1,":S: \tShutting down Waitable Timer Server...\n");
ShutDownWait();
DEBUG_FLUSH();
//
// ShutDown the outbound log processor
//
//
// NOPE; the database server requires the outbound log
// processor when shutting down. The database server will
// shutdown the outbound log processor when its done.
//
// DPRINT(1,"\tShutting down Outbound Log Processor...\n");
// DEBUG_FLUSH();
// ShutDownOutLog();
//
// ShutDown the database server
//
DPRINT(1,":S: \tShutting down the Database Server...\n");
DEBUG_FLUSH();
DbsShutDown();
//
// Wakeup any command server waiting on another command server to start
//
if (HANDLE_IS_VALID(DataBaseEvent)) {
SetEvent(DataBaseEvent);
}
if (HANDLE_IS_VALID(JournalEvent)) {
SetEvent(JournalEvent);
}
if (HANDLE_IS_VALID(ChgOrdEvent)) {
SetEvent(ChgOrdEvent);
}
if (HANDLE_IS_VALID(CommEvent)) {
SetEvent(CommEvent);
}
if (HANDLE_IS_VALID(ReplicaEvent)) {
SetEvent(ReplicaEvent);
}
//
// Wakeup the thread that polls the ds
//
if (HANDLE_IS_VALID(DsPollEvent)) {
SetEvent(DsPollEvent);
}
//
// Wakeup any thread waiting on the thread that polls the ds
//
if (HANDLE_IS_VALID(DsShutDownComplete)) {
SetEvent(DsShutDownComplete);
}
//
// Ask all the threads to exit
//
DPRINT(1,":S: \tShutting down all the threads...\n");
WStatus = ThSupExitThreadGroup(NULL);
DEBUG_FLUSH();
//
// We can't uninitialize the subsystems because some thread
// may still be active and referencing the data structs.
//
if (WIN_SUCCESS(WStatus)) {
//
// Free the active replica set stuff
//
DPRINT(1,":S: \tFreeing replica sets...\n");
RcsFrsUnInitializeReplicaCmdServer();
DEBUG_FLUSH();
//
// Free the rpc handle cache
//
DPRINT(1,":S: \tFreeing rpc handles...\n");
SndCsUnInitialize();
DEBUG_FLUSH();
//
// Free the stage table
//
DPRINT(1,":S: \tFreeing stage table...\n");
FrsStageCsUnInitialize();
DEBUG_FLUSH();
//
// Free the rpc table and princname
//
DPRINT(1,":S: \tFreeing rpc memory...\n");
FrsRpcUnInitialize();
DEBUG_FLUSH();
}
#if DBG
//
// DEBUG PRINTS
//
DPRINT(1,":S: \tDumping Vme Filter Table...\n");
JrnlDumpVmeFilterTable();
DEBUG_FLUSH();
#endif DBG
SHUTDOWN_COMPLETE:
//
// We can't free resources because some thread may still be
// active and referencing them.
//
if (WIN_SUCCESS(WStatus)) {
//
//
// Free resources in main
//
DPRINT(1,":S: \tFreeing main resources...\n");
DEBUG_FLUSH();
FrsFree(WorkingPath);
FrsFree(DbLogPath);
FrsFree(JetPath);
FrsFree(JetFile);
FrsFree(JetFileCompact);
FrsFree(JetSys);
FrsFree(JetTemp);
FrsFree(JetLog);
FrsFree(JetPathA);
FrsFree(JetFileA);
FrsFree(JetFileCompactA);
FrsFree(JetSysA);
FrsFree(JetTempA);
FrsFree(JetLogA);
GTabFreeTable(StagingAreaTable, FrsFree);
//
// Uninitialize the memory allocation subsystem
//
DPRINT(1,":S: \tShutting down the memory allocation subsystem...\n");
DEBUG_FLUSH();
FrsUnInitializeMemAlloc();
}
//
// Report an event
//
if (FrsIsAsserting) {
EPRINT0(EVENT_FRS_STOPPED_ASSERT);
} else {
EPRINT0(EVENT_FRS_STOPPED);
}
//
// Check the restart action.
//
MainShutDownComplete();
//
// DONE
//
if (!FrsIsAsserting && FrsScmRequestedShutdown) {
SetEvent(ShutDownComplete);
FrsSetServiceStatus(SERVICE_STOPPED, 0, ShutDownTimeOut*1000, NO_ERROR);
}
ExitProcess(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
DWORD
MainMustInit(
IN INT ArgC,
IN PWCHAR *ArgV
)
/*++
Routine Description:
Initialize anything necessary for shutdown and logging errors.
Arguments:
ArgC - From main
ArgV - From main
Return Value:
Win32 Error Status
--*/
{
#undef DEBSUB
#define DEBSUB "MainMustInit:"
DWORD WStatus;
ULONG Len;
PWCHAR Severity;
HANDLE ShutDownThreadHandle;
DWORD ShutDownThreadId;
//
// Several lower level functions aren't prepared to dynamically allocate
// the needed storage so to help mitigate this we use the BigPath crock.
//
WCHAR BigPath[8*MAX_PATH + 1];
//
// FIRST, SETUP THE "MUST HAVE" VARIABLES, EVENTS, SERVICES...
//
//
// Synchronizes access between DsCs and SysVol Promotion when
// initializing other the rest of the service (MainInit()).
//
InitializeCriticalSection(&MainInitLock);
//
// Enable event logging
//
//InitializeEventLog();
//EPRINT0(EVENT_FRS_STARTING);
//
// Backup/Restore privileges
//
if (!FrsSetupPrivileges()) {
WStatus = GetLastError();
DPRINT_WS(0, ":S: ERROR - FrsSetupPrivileges()", WStatus);
return WStatus;
}
DEBUG_FLUSH();
//
// Get this Machine's name.
//
DPRINT1(0, ":S: Computer name is %ws\n", ComputerName);
//
// Get this Machine's DNS name.
//
Len = ARRAY_SZ(BigPath);
BigPath[0] = L'\0';
if (!GetComputerNameEx(ComputerNameDnsFullyQualified, BigPath, &Len)) {
WStatus = GetLastError();
DPRINT1_WS(0, "ERROR - Cannot get the computer's DNS name; using %ws\n",
ComputerName, WStatus);
ComputerDnsName = FrsWcsDup(ComputerName);
} else {
ComputerDnsName = FrsWcsDup(BigPath);
}
DPRINT1(0, "Computer's DNS name is %ws\n", ComputerDnsName);
DEBUG_FLUSH();
if (!RunningAsAService) {
//
// We need the event log service to log errors, warnings, notes, ...
//
EventLogIsRunning = FrsWaitService(ComputerName, L"EventLog", 1000, 10000);
if (!EventLogIsRunning) {
return ERROR_SERVICE_NOT_ACTIVE;
}
//
// We need the rpc endpoint mapper
//
RpcssIsRunning = FrsWaitService(ComputerName, L"rpcss", 1000, 10000);
if (!RpcssIsRunning) {
return ERROR_SERVICE_NOT_ACTIVE;
}
}
//
// Signaled when shutdown is desired
//
ShutDownEvent = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when shutdown has completed
//
ShutDownComplete = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when database has started
//
DataBaseEvent = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when journal has started
//
JournalEvent = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when change order accept has started
//
ChgOrdEvent = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when replica has started
//
ReplicaEvent = FrsCreateEvent(TRUE, FALSE);
//
// Signaled when comm has started
//
CommEvent = FrsCreateEvent(TRUE, FALSE);
//
// Used to poll the ds
//
DsPollEvent = FrsCreateEvent(TRUE, FALSE);
//
// Set when the thread that polls the Ds has shut down
//
DsShutDownComplete = FrsCreateEvent(TRUE, FALSE);
//
// register signal handlers after creating events and initializing
// the critical sections!
//
if (!RunningAsAService) {
DPRINT(0, "Setting CTRL_C_EVENT and CTRL_BREAK_EVENT handlers.\n");
if(!SetConsoleCtrlHandler(MainSigHandler, TRUE)) {
DPRINT_WS(0, "SetConsoleCtrlHandler() failed:", GetLastError());
}
}
//
// Get the path to the DB file and the DB Logs.
//
CfgRegReadString(FKC_WORKING_DIRECTORY, NULL, 0, &WorkingPath);
if (WorkingPath == NULL) {
DPRINT(0, ":S: Must have the working directory in the registry. Aborting\n");
return ERROR_INVALID_PARAMETER;
}
CfgRegReadString(FKC_DBLOG_DIRECTORY, NULL, 0, &DbLogPath);
//
// Create the working directory and the DB log dir (optional)
//
FRS_WCSLWR(WorkingPath);
DPRINT1(0, ":S: Working Directory is %ws\n", WorkingPath);
WStatus = FrsCreateDirectory(WorkingPath);
CLEANUP_WS(0, ":S: Can't create working dir:", WStatus, CLEAN_UP);
if (DbLogPath != NULL) {
FRS_WCSLWR(DbLogPath);
DPRINT1(0, ":S: DB Log Path provided is %ws\n", DbLogPath);
WStatus = FrsCreateDirectory(DbLogPath);
CLEANUP_WS(0, ":S: Can't create debug log dir:", WStatus, CLEAN_UP);
}
//
// Restrict access to the database working directory
//
WStatus = FrsRestrictAccessToFileOrDirectory(WorkingPath, NULL, TRUE);
DPRINT1_WS(0, ":S: WARN - Failed to restrict access to %ws (IGNORED);",
WorkingPath, WStatus);
WStatus = ERROR_SUCCESS;
//
// Restrict access to the database log directory (optional)
//
if (DbLogPath != NULL) {
WStatus = FrsRestrictAccessToFileOrDirectory(DbLogPath, NULL, TRUE);
DPRINT1_WS(0, ":S: WARN - Failed to restrict access to %ws (IGNORED);",
DbLogPath, WStatus);
WStatus = ERROR_SUCCESS;
}
//
// Create the database path
// WARN: FrsDsInitializeHardWired() may alter JetPath
//
JetPath = FrsWcsPath(WorkingPath, JET_DIR);
//
// Initialize the hardwired config stuff
// WARN: FrsDsInitializeHardWired() may alter JetPath
//
INITIALIZE_HARD_WIRED();
//
// Create the database paths and file (UNICODE and ASCII)
// Jet uses the ASCII versions
//
FRS_WCSLWR(JetPath); // for wcsstr()
JetFile = FrsWcsPath(JetPath, JET_FILE);
JetFileCompact = FrsWcsPath(JetPath, JET_FILE_COMPACT);
JetSys = FrsWcsPath(JetPath, JET_SYS);
JetTemp = FrsWcsPath(JetPath, JET_TEMP);
if (DbLogPath != NULL) {
JetLog = FrsWcsDup(DbLogPath);
} else {
JetLog = FrsWcsPath(JetPath, JET_LOG);
}
//
// Jet can't handle wide char strings
//
JetPathA = FrsWtoA(JetPath);
JetFileA = FrsWtoA(JetFile);
JetFileCompactA = FrsWtoA(JetFileCompact);
JetSysA = FrsWtoA(JetSys);
JetTempA = FrsWtoA(JetTemp);
JetLogA = FrsWtoA(JetLog);
DPRINT2(4, ":S: JetPath : %ws (%s in ASCII)\n", JetPath, JetPathA);
DPRINT2(4, ":S: JetFile : %ws (%s in ASCII)\n", JetFile, JetFileA);
DPRINT2(4, ":S: JetFileCompact: %ws (%s in ASCII)\n", JetFileCompact, JetFileCompactA);
DPRINT2(4, ":S: JetSys : %ws (%s in ASCII)\n", JetSys, JetSysA);
DPRINT2(4, ":S: JetTemp : %ws (%s in ASCII)\n", JetTemp, JetTempA);
DPRINT2(4, ":S: JetLog : %ws (%s in ASCII)\n", JetLog, JetLogA);
//
// Create the database directories under workingpath\JET_DIR
//
WStatus = FrsCreateDirectory(JetPath);
CLEANUP_WS(0, ":S: Can't create JetPath dir:", WStatus, CLEAN_UP);
WStatus = FrsCreateDirectory(JetSys);
CLEANUP_WS(0, ":S: Can't create JetSys dir:", WStatus, CLEAN_UP);
WStatus = FrsCreateDirectory(JetTemp);
CLEANUP_WS(0, ":S: Can't create JetTemp dir:", WStatus, CLEAN_UP);
WStatus = FrsCreateDirectory(JetLog);
CLEANUP_WS(0, ":S: Can't create JetLog dir:", WStatus, CLEAN_UP);
//
// Initialize the subsystem used for managing threads
// (needed for an orderly shutdown)
//
ThSupInitialize();
//
// This thread responds to the ShutDownEvent and insures
// an orderly shutdown when run as either a service or an exe.
//
ShutDownThreadHandle = (HANDLE)CreateThread(NULL,
10000,
MainFrsShutDown,
NULL,
0,
&ShutDownThreadId);
if (!HANDLE_IS_VALID(ShutDownThreadHandle)) {
WStatus = GetLastError();
CLEANUP_WS(0, ":S: Can't create shutdown thread:", WStatus, CLEAN_UP);
}
DbgCaptureThreadInfo2(L"Shutdown", MainFrsShutDown, ShutDownThreadId);
//
// The rpc server may reference this table as soon as the rpc
// interfaces are registered. Make sure it exists early in the
// startup.
//
ReplicasByGuid = GTabAllocTable();
//
// The staging area table is referenced early in the startup threads
//
StagingAreaTable = GTabAllocTable();
CompressionTable = GTabAllocTable();
if (!DebugInfo.DisableCompression) {
DPRINT(0, "Staging file COMPRESSION support is enabled.\n");
//
// The Compression table is inited from the registry. Add the guids for the
// compression formats that we support.
//
GTabInsertEntryNoLock(CompressionTable, (PVOID)&FrsGuidCompressionFormatLZNT1, (GUID*)&FrsGuidCompressionFormatLZNT1, NULL);
} else {
DPRINT(0, "Staging file COMPRESSION support is disabled.\n");
}
//
// Size of buffer used during directory enumeration
//
CfgRegReadDWord(FKC_ENUMERATE_DIRECTORY_SIZE, NULL, 0, &EnumerateDirectorySizeInBytes);
DPRINT1(4, ":S: Registry Param - Enumerate Directory Buffer Size in Bytes: %d\n",
EnumerateDirectorySizeInBytes);
//
// Default File and Directory filter lists.
//
// The compiled in default is only used if no value is supplied in
// EITHER the DS or the Registry.
// The table below shows how the final filter is formed.
//
// value Value
// supplied supplied Resulting filter string Used
// in DS in Registry
// No No DEFAULT_xxx_FILTER_LIST
// No Yes Value from registry
// Yes No Value from DS
// Yes Yes Value from DS + Value from registry
//
RegistryFileExclFilterList = NULL;
CfgRegReadString(FKC_FILE_EXCL_FILTER_LIST, NULL, 0, &RegistryFileExclFilterList);
RegistryDirExclFilterList = NULL;
CfgRegReadString(FKC_DIR_EXCL_FILTER_LIST, NULL, 0, &RegistryDirExclFilterList);
DPRINT1(4, ":S: Registry Param - File Filter List: %ws\n",
(RegistryFileExclFilterList) ? RegistryFileExclFilterList : L"Null");
DPRINT1(4, ":S: Registry Param - Directory Filter Exclusion List: %ws\n",
(RegistryDirExclFilterList) ? RegistryDirExclFilterList : L"Null");
//
// Inclusion filters were added very late (7/13/99) so a single file
// ~clbcatq.* could be made to replicate. This is a reg only key.
//
// Add the File Inclusion Filter List Value to the Reg key
// "HKLM\System\CurrentControlSet\Services\NtFrs\Parameters"
//
// If the value already exists then preserve it.
//
CfgRegWriteString(FKC_FILE_INCL_FILTER_LIST,
NULL,
FRS_RKF_FORCE_DEFAULT_VALUE | FRS_RKF_KEEP_EXISTING_VALUE,
0);
RegistryFileInclFilterList = NULL;
CfgRegReadString(FKC_FILE_INCL_FILTER_LIST, NULL, 0, &RegistryFileInclFilterList);
RegistryDirInclFilterList = NULL;
CfgRegReadString(FKC_DIR_INCL_FILTER_LIST, NULL, 0, &RegistryDirInclFilterList);
DPRINT1(4, ":S: Registry Param - File Filter Inclusion List: %ws\n",
(RegistryFileInclFilterList) ? RegistryFileInclFilterList : L"Null");
DPRINT1(4, ":S: Registry Param - Directory Filter Inclusion List: %ws\n",
(RegistryDirInclFilterList) ? RegistryDirInclFilterList : L"Null");
//
// Mutual Authentication. Update registry value as needed.
//
CfgRegCheckEnable(FKC_FRS_MUTUAL_AUTHENTICATION_IS,
NULL,
0,
&MutualAuthenticationIsEnabled);
// WStatus = ConfigCheckEnabledWithUpdate(FRS_CONFIG_SECTION,
// FRS_MUTUAL_AUTHENTICATION_IS,
// FRS_IS_DEFAULT_ENABLED,
// &MutualAuthenticationIsEnabled);
//
// if (!MutualAuthenticationIsEnabled) {
// DPRINT_WS(0, "WARN - Mutual authentication is not enabled", WStatus);
// } else {
// DPRINT(4, "Mutual authentication is enabled\n");
// }
//
// Initialize the Perfmon server
//
InitializePerfmonServer();
//
// Create registry keys for checking access to RPC calls
//
FrsRpcInitializeAccessChecks();
//
// Register the RPC interfaces
//
if (!FrsRpcInitialize()) {
return RPC_S_CANT_CREATE_ENDPOINT;
}
return ERROR_SUCCESS;
CLEAN_UP:
return WStatus;
}
VOID
MainInit(
VOID
)
/*++
Routine Description:
Initialize anything necessary to run the service
Arguments:
None.
Return Value:
None.
--*/
{
#undef DEBSUB
#define DEBSUB "MainInit:"
EnterCriticalSection(&MainInitLock);
//
// No need to initialize twice
//
if (MainInitHasRun) {
LeaveCriticalSection(&MainInitLock);
return;
}
//
// SETUP THE INFRASTRUCTURE
//
//
// Reset our start time (in minutes). The service is not restarted
// unless this invocation ran long enough before taking an assert.
//
// 100-nsecs / (10 (microsecs) * 1000 (msecs) * 1000 (secs) * 60 (min)
//
GetSystemTimeAsFileTime((FILETIME *)&DebugInfo.StartSeconds);
DebugInfo.StartSeconds /= (10 * 1000 * 1000);
//
// Fetch the staging file limit
//
CfgRegReadDWord(FKC_STAGING_LIMIT, NULL, 0, &StagingLimitInKb);
DPRINT1(4, ":S: Staging limit is: %d KB\n", StagingLimitInKb);
//
// Put the default value in registry if there is no key present.
//
CfgRegWriteDWord(FKC_STAGING_LIMIT,
NULL,
FRS_RKF_FORCE_DEFAULT_VALUE | FRS_RKF_KEEP_EXISTING_VALUE,
0);
//
// Get Max number of replica sets allowed.
//
CfgRegReadDWord(FKC_MAX_NUMBER_REPLICA_SETS, NULL, 0, &MaxNumberReplicaSets);
//
// Get Max number of Jet database sessions allowed.
//
CfgRegReadDWord(FKC_MAX_NUMBER_JET_SESSIONS, NULL, 0, &MaxNumberJetSessions);
//
// Get outstanding CO qutoa limit on outbound connections.
//
CfgRegReadDWord(FKC_OUT_LOG_CO_QUOTA, NULL, 0, &MaxOutLogCoQuota);
//
// Get boolean to tell us to preserve file object IDs
// -- See Bug 352250 for why this is a risky thing to do.
CfgRegReadDWord(FKC_PRESERVE_FILE_OID, NULL, 0, &PreserveFileOID);
//
// Get the service long name for use in error messages.
//
ServiceLongName = FrsGetResourceStr(IDS_SERVICE_LONG_NAME);
//
// Initialize the Delayed command server. This command server
// is really a timeout queue that the other command servers use
// to retry or check the state of previously issued commands that
// have an indeterminate completion time.
//
// WARN: MUST BE FIRST -- Some command servers may use this
// command server during their initialization.
//
WaitInitialize();
FrsDelCsInitialize();
//
// SETUP THE COMM LAYER
//
//
// Initialize the low level comm subsystem
//
CommInitializeCommSubsystem();
//
// Initialize the Send command server. The receive command server
// starts when we register our RPC interface.
//
SndCsInitialize();
//
// SETUP THE SUPPORT COMMAND SERVERS
//
//
// Staging file fetcher
//
FrsFetchCsInitialize();
//
// Initial Sync Controller
//
InitSyncCsInitialize();
//
// Staging file installer
//
FrsInstallCsInitialize();
//
// Staging file generator
//
FrsStageCsInitialize();
//
// outbound log processor
//
OutLogInitialize();
//
// LAST, KICK OFF REPLICATION
//
//
// MUST PRECEED DATABASE AND DS INITIALIZATION
//
// The DS command server and the Database command server depend on
// the replica control initialization.
//
// Initialize the replica control command server
//
RcsInitializeReplicaCmdServer();
//
// Actually, we can start the database at any time after the delayed
// command server and the replica control command server. But its
// a good idea to fail sooner than later to make cleanup more predictable.
//
DbsInitialize();
//
// Free up memory by reducing our working set size
//
SetProcessWorkingSetSize(ProcessHandle, (SIZE_T)-1, (SIZE_T)-1);
MainInitHasRun = TRUE;
LeaveCriticalSection(&MainInitLock);
}
VOID
MainMinimumInit(
VOID
)
/*++
Routine Description:
Initialize anything necessary to run the service
Arguments:
None.
Return Value:
TRUE - No problems
FALSE - Can't start service
--*/
{
#undef DEBSUB
#define DEBSUB "MainMinimumInit:"
//
// Setup the infrastructure
//
DbgMinimumInit();
//
// Check some NT to WIN error translations
//
FRS_ASSERT(WIN_NOT_IMPLEMENTED(FrsSetLastNTError(STATUS_NOT_IMPLEMENTED)));
FRS_ASSERT(WIN_SUCCESS(FrsSetLastNTError(STATUS_SUCCESS)));
FRS_ASSERT(WIN_ACCESS_DENIED(FrsSetLastNTError(STATUS_ACCESS_DENIED)));
FRS_ASSERT(WIN_INVALID_PARAMETER(FrsSetLastNTError(STATUS_INVALID_PARAMETER)));
FRS_ASSERT(WIN_NOT_FOUND(FrsSetLastNTError(STATUS_OBJECT_NAME_NOT_FOUND)));
//
// Initialize the DS command server
//
FrsDsInitialize();
//
// Free up memory by reducing our working set size
//
SetProcessWorkingSetSize(ProcessHandle, (SIZE_T)-1, (SIZE_T)-1);
}
PWCHAR *
MainConvertArgV(
DWORD ArgC,
PCHAR *ArgV
)
/*++
Routine Description:
Convert short char ArgV into wide char ArgV
Arguments:
ArgC - From main
ArgV - From main
Return Value:
Address of the new ArgV
--*/
{
#undef DEBSUB
#define DEBSUB "MainConvertArgV:"
PWCHAR *wideArgV;
wideArgV = FrsAlloc((ArgC + 1) * sizeof(PWCHAR));
wideArgV[ArgC] = NULL;
while (ArgC-- >= 1) {
wideArgV[ArgC] = FrsAlloc((strlen(ArgV[ArgC]) + 1) * sizeof(WCHAR));
wsprintf(wideArgV[ArgC], L"%hs", ArgV[ArgC]);
FRS_WCSLWR(wideArgV[ArgC]);
}
return wideArgV;
}
VOID
MainServiceHandler(
IN DWORD ControlCode
)
/*++
Routine Description:
Service handler. Called by the service controller runtime
Arguments:
ControlCode
Return Value:
None.
--*/
{
#undef DEBSUB
#define DEBSUB "MainServiceHandler:"
DPRINT1(0, ":S: Received control code %d from Service Controller\n",ControlCode);
switch (ControlCode) {
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
DPRINT1(0, ":S: Service controller requests shutdown in %d seconds...\n",
ShutDownTimeOut);
FrsSetServiceStatus(SERVICE_STOP_PENDING, 0, ShutDownTimeOut * 1000, NO_ERROR);
FrsScmRequestedShutdown = TRUE;
FrsIsShuttingDown = TRUE;
SetEvent(ShutDownEvent);
return;
case SERVICE_CONTROL_PAUSE:
case SERVICE_CONTROL_CONTINUE:
DPRINT(0, ":S: SERVICE PAUSE/CONTINUE IS NOT IMPLEMENTED\n");
return;
case SERVICE_CONTROL_INTERROGATE:
return;
default:
DPRINT2(0, ":S: Handler for service %ws does not understand 0x%x\n",
SERVICE_NAME, ControlCode);
}
return;
}
VOID
WINAPI
MainRunningAsAService(
IN DWORD ArgC,
IN PWCHAR *ArgV
)
/*++
Routine Description:
Main routine when running as a service
Arguments:
ArgC - Ignored
ArgV - Ignored
Return Value:
None.
--*/
{
#undef DEBSUB
#define DEBSUB "MainRunningAsAService:"
HANDLE StartupThreadHandle;
DWORD StartupThreadId;
DWORD WStatus;
PDWORD ServiceWaitState = NULL;
DPRINT(0, "Running as a service\n");
//
// Register our handlers
//
ServiceStatusHandle = RegisterServiceCtrlHandler(SERVICE_NAME, MainServiceHandler);
if (!ServiceStatusHandle) {
DPRINT1_WS(0, ":S: ERROR - No ServiceStatusHandle for %ws;",
SERVICE_NAME, GetLastError());
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_PROCESS_ABORTED;
ServiceStatus.dwWaitHint = DEFAULT_SHUTDOWN_TIMEOUT * 1000;
return;
}
if (!FrsIsShuttingDown) {
FrsSetServiceStatus(SERVICE_START_PENDING,
0,
DEFAULT_STARTUP_TIMEOUT * 1000,
NO_ERROR);
}
//
// Kick off a thread that updates the checkpoint and
// keeps the service controller from timing out.
// Allocate memory for data to be passed to another thread.
//
ServiceWaitState = FrsAlloc(sizeof(DWORD));
*ServiceWaitState = SERVICE_START_PENDING;
StartupThreadHandle = (HANDLE)CreateThread(NULL,
10000,
MainSCCheckPointUpdate,
ServiceWaitState,
0,
&StartupThreadId);
if (!HANDLE_IS_VALID(StartupThreadHandle)) {
//
// Not a fatal error. It is OK to not update the checkpoint.
//
DPRINT_WS(4,":S: ERROR - Could not start thread to update startup checkpoint.", GetLastError());
}
//
// Finish rest of debug input
//
DbgMustInit(ArgC, WideArgV);
//
// Critical initialization
//
DPRINT1(4, "ArgC = %d\n", ArgC);
WStatus = MainMustInit(ArgC, WideArgV);
if (FRS_SUCCESS(WStatus)) {
//
// Necessary initialization
//
MainMinimumInit();
if (!FrsIsShuttingDown) {
//
// The core service has started.
//
FrsSetServiceStatus(SERVICE_RUNNING,
0,
DEFAULT_STARTUP_TIMEOUT * 1000,
NO_ERROR);
//
// Init the service restart action if service fails.
//
FrsSetServiceFailureAction();
}
} else {
//
// Initialization failed; service can't start
//
DPRINT_WS(0, ":S: MainMustInit failed;", WStatus);
FrsSetServiceStatus(SERVICE_STOPPED,
0,
DEFAULT_SHUTDOWN_TIMEOUT * 1000,
ERROR_PROCESS_ABORTED);
}
return;
}
ULONG
MainNotRunningAsAService(
IN DWORD ArgC,
IN PWCHAR *ArgV
)
/*++
Routine Description:
Main routine when not running as a service
Arguments:
ArgC - Ignored
ArgV - Ignored
Return Value:
Win32 status
--*/
{
#undef DEBSUB
#define DEBSUB "MainNotRunningAsAService:"
ULONG WStatus;
DPRINT(0, "Not running as a service\n");
//
// Finish rest of debug input
//
DbgMustInit(ArgC, WideArgV);
//
// Critical initialization
//
DPRINT1(4, "ArgC = %d\n", ArgC);
WStatus = MainMustInit(ArgC, WideArgV);
if (!FRS_SUCCESS(WStatus)) {
DPRINT_WS(0, ":S: MainMustInit failed;", WStatus);
ExitProcess(ERROR_NO_SYSTEM_RESOURCES);
}
//
// Necessary initialization
//
MainMinimumInit();
#if DBG
//
// Kick off the test thread and forget about it
//
if (!ThSupCreateThread(L"TestThread", NULL, FrsTest, NULL)) {
DPRINT(0, ":S: Could not create FrsTest\n");
}
#endif DBG
//
// Wait for shutdown
//
DPRINT(0, ":S: Waiting for shutdown event.\n");
WStatus = WaitForSingleObject(ShutDownEvent, INFINITE);
CHECK_WAIT_ERRORS(0, WStatus, 1, ACTION_CONTINUE);
DPRINT(0, ":S: Waiting for shutdown complete event.\n");
WStatus = WaitForSingleObject(ShutDownComplete, INFINITE);
CHECK_WAIT_ERRORS(0, WStatus, 1, ACTION_CONTINUE);
if (WIN_SUCCESS(WStatus)) {
DPRINT(0, ":S: ShutDownComplete event signalled.\n");
}
return WStatus;
}
ULONG
_cdecl
main(
IN INT ArgC,
IN PCHAR ArgV[]
)
/*++
Routine Description:
Main runs as either a service or an exe.
Arguments:
ArgC
ArgV
Return Value:
ERROR_SUCCESS - No problems
Otherwise - Something went wrong
--*/
{
#undef DEBSUB
#define DEBSUB "main:"
DWORD Len;
ULONG WStatus;
SERVICE_TABLE_ENTRY ServiceTableEntry[] = {
{ SERVICE_NAME, MainRunningAsAService },
{ NULL, NULL }
};
//
// Process Handle
//
ProcessHandle = GetCurrentProcess();
//
// Disable any DPRINTs until we can init the debug component.
//
DebugInfo.Disabled = TRUE;
//
// Adjust the defaults for some tunable params.
//
CfgRegAdjustTuningDefaults();
//
// Get this Machine's name.
//
Len = MAX_COMPUTERNAME_LENGTH + 2;
ComputerName[0] = UNICODE_NULL;
GetComputerNameW(ComputerName, &Len);
ComputerName[Len] = UNICODE_NULL;
//
// Initialize the memory allocation subsystem
//
FrsInitializeMemAlloc();
//
// Perform as much work as possible in WCHAR
//
WideArgV = MainConvertArgV(ArgC, ArgV);
//
// Find out if we are running as a service or as an .exe
//
RunningAsAService = !FrsSearchArgv(ArgC, WideArgV, L"notservice", NULL);
//
// Synchronizes access between the shutdown thread and the
// service controller.
//
InitializeCriticalSection(&ServiceLock);
//
// Init the debug trace log.
//
DbgInitLogTraceFile(ArgC, WideArgV);
//
// Enable event logging
//
InitializeEventLog();
EPRINT0(EVENT_FRS_STARTING);
WStatus = ERROR_SUCCESS;
try {
try {
if (RunningAsAService) {
//
// RUNNING AS A SERVICE
//
if (!StartServiceCtrlDispatcher(ServiceTableEntry)) {
WStatus = GetLastError();
DPRINT1_WS(0, "Could not start dispatcher for service %ws;",
SERVICE_NAME, WStatus);
}
} else {
//
// NOT A SERVICE
//
MainNotRunningAsAService(ArgC, WideArgV);
}
} except (FrsException(GetExceptionInformation())) {
}
} finally {
if (AbnormalTermination()) {
WStatus = ERROR_INVALID_ACCESS;
}
}
return WStatus;
}
Reference in a new issue Copy permalink