mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2370 lines
60 KiB
2370 lines
60 KiB
/*++
|
|
|
|
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;
|
|
}
|