/*++ Copyright (c) 2013 Minoca Corp. All Rights Reserved Module Name: osbase.c Abstract: This module implements the Operating System Base interface. Author: Evan Green 25-Feb-2013 Environment: User mode --*/ // // ------------------------------------------------------------------- Includes // #include "osbasep.h" // // ---------------------------------------------------------------- Definitions // #define OS_MOUNT_ALLOCATION_TAG 0x744D734F // 'tMsO' #define OS_VERSION_ALLOCATION_TAG 0x73726556 // 'sreV' #define OS_CURRENT_DIRECTORY_ALLOCATION_TAG 0x6443734F // 'dCsO' // // Defines the number of times the get mount points routine should try to // collect mount points. // #define OS_GET_MOUNT_POINTS_TRY_COUNT 5 // // Defines the initial size of the mount points buffer. // #define OS_GET_MOUNT_POINTS_BUFFER_SIZE_GUESS 4096 // // Defines the number of times the get current directory routine should try // to collect the current directory string. // #define OS_GET_CURRENT_DIRECTORY_TRY_COUNT 5 // // Defines the initial size of the current directory buffer. // #define OS_GET_CURRENT_DIRECTORY_BUFFER_SIZE_GUESS 256 // // ------------------------------------------------------ Data Type Definitions // // // ----------------------------------------------- Internal Function Prototypes // PVOID OspSetSignalHandler ( PVOID SignalHandlerRoutine ); KSTATUS OspGetSetFileInformation ( HANDLE Directory, PSTR Path, ULONG PathSize, BOOL FollowLink, PSET_FILE_INFORMATION Request ); KSTATUS OspMountOrUnmount ( PSTR MountPointPath, ULONG MountPointPathSize, PSTR TargetPath, ULONG TargetPathSize, ULONG Flags ); NO_RETURN VOID OspExitThread ( PVOID UnmapAddress, UINTN UnmapSize ); // // -------------------------------------------------------------------- Globals // // // Store a boolean indicating whether this library is initialized or not to be // moderately defensive against people accidentally calling this routine // multiple times. // BOOL OsLibraryInitialized = FALSE; // // Store a pointer to the signal handling routine. // volatile PSIGNAL_HANDLER_ROUTINE OsSignalHandler = NULL; // // Store pointers to the system version information if it has been requested // already. // PSTR OsProductName; PSTR OsBuildString; ULONG OsSystemVersionStringsSize; // // ------------------------------------------------------------------ Functions // OS_API VOID OsInitializeLibrary ( PPROCESS_ENVIRONMENT Environment ) /*++ Routine Description: This routine initializes the base OS library. It needs to be called only once, when the library is first loaded. Arguments: Environment - Supplies a pointer to the environment information. Return Value: None. --*/ { if (OsLibraryInitialized != FALSE) { return; } OsEnvironment = Environment; OsLibraryInitialized = TRUE; OspSetUpSystemCalls(); OspInitializeMemory(); OspInitializeImageSupport(); OspInitializeThreadSupport(); // // Register the signal handler to start receiving signals. // OspSetSignalHandler(OspSignalHandler); return; } OS_API VOID OsTestSystemCall ( VOID ) /*++ Routine Description: This routine performs a meaningless system call. Arguments: None. Return Value: None. --*/ { OsSystemCall(SystemCallInvalid, NULL); return; } OS_API KSTATUS OsOpen ( HANDLE Directory, PSTR Path, ULONG PathLength, ULONG Flags, FILE_PERMISSIONS CreatePermissions, PHANDLE Handle ) /*++ Routine Description: This routine opens a file or other I/O object. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to a string containing the path of the object to open. PathLength - Supplies the length of the path buffer, in bytes, including the null terminator. Flags - Supplies flags associated with the open operation. See SYS_OPEN_FLAG_* definitions. CreatePermissions - Supplies the permissions for create operations. Handle - Supplies a pointer where a handle will be returned on success. Return Value: Status code. --*/ { SYSTEM_CALL_OPEN Parameters; Parameters.Directory = Directory; Parameters.Path = Path; Parameters.PathBufferLength = PathLength; Parameters.Flags = Flags; Parameters.CreatePermissions = CreatePermissions & FILE_PERMISSION_MASK; OsSystemCall(SystemCallOpen, &Parameters); *Handle = Parameters.Handle; return Parameters.Status; } OS_API KSTATUS OsOpenDevice ( DEVICE_ID DeviceId, ULONG Flags, PHANDLE Handle ) /*++ Routine Description: This routine opens a device directly. Arguments: DeviceId - Supplies the identifier of the device to open. Flags - Supplies flags associated with the open operation. See SYS_OPEN_FLAG_* definitions. Handle - Supplies a pointer where a handle will be returned on success. Return Value: Status code. --*/ { SYSTEM_CALL_OPEN_DEVICE Parameters; Parameters.DeviceId = DeviceId; Parameters.Flags = Flags; OsSystemCall(SystemCallOpenDevice, &Parameters); *Handle = Parameters.Handle; return Parameters.Status; } OS_API KSTATUS OsClose ( HANDLE Handle ) /*++ Routine Description: This routine closes an I/O handle. Arguments: Handle - Supplies a pointer to the open handle. Return Value: Status code. --*/ { SYSTEM_CALL_CLOSE Parameters; Parameters.Handle = Handle; OsSystemCall(SystemCallClose, &Parameters); return Parameters.Status; } OS_API KSTATUS OsPerformIo ( HANDLE Handle, IO_OFFSET Offset, UINTN Size, ULONG Flags, ULONG TimeoutInMilliseconds, PVOID Buffer, PUINTN BytesCompleted ) /*++ Routine Description: This routine performs I/O on an open handle. Arguments: Handle - Supplies a pointer to the opened I/O handle. Offset - Supplies the offset into the file to read from or write to. Set this to IO_OFFSET_NONE to do I/O at the current file position or for handles that are not seekable. Size - Supplies the number of bytes to transfer. Flags - Supplies a bitfield of flags. See SYS_IO_FLAG_* definitions. TimeoutInMilliseconds - Supplies the number of milliseconds that the I/O operation should be waited on before timing out. Use SYS_WAIT_TIME_INDEFINITE to wait forever on the I/O. Buffer - Supplies a pointer to the buffer containing the data to write or where the read data should be returned, depending on the operation. BytesCompleted - Supplies a pointer where the number of bytes completed will be returned. Return Value: Status code. --*/ { SYSTEM_CALL_PERFORM_IO Parameters; Parameters.Handle = Handle; Parameters.Buffer = Buffer; Parameters.Flags = Flags; Parameters.TimeoutInMilliseconds = TimeoutInMilliseconds; Parameters.Offset = Offset; Parameters.Size = Size; OsSystemCall(SystemCallPerformIo, &Parameters); *BytesCompleted = Parameters.Size; return Parameters.Status; } OS_API KSTATUS OsPerformVectoredIo ( HANDLE Handle, IO_OFFSET Offset, UINTN Size, ULONG Flags, ULONG TimeoutInMilliseconds, PIO_VECTOR VectorArray, UINTN VectorCount, PUINTN BytesCompleted ) /*++ Routine Description: This routine performs I/O on an open handle. Arguments: Handle - Supplies a pointer to the opened I/O handle. Offset - Supplies the offset into the file to read from or write to. Set this to IO_OFFSET_NONE to do I/O at the current file position or for handles that are not seekable. Size - Supplies the number of bytes to transfer. Flags - Supplies a bitfield of flags. See SYS_IO_FLAG_* definitions. TimeoutInMilliseconds - Supplies the number of milliseconds that the I/O operation should be waited on before timing out. Use SYS_WAIT_TIME_INDEFINITE to wait forever on the I/O. VectorArray - Supplies an array of I/O vector structures to do I/O to/from. VectorCount - Supplies the number of elements in the vector array. BytesCompleted - Supplies a pointer where the number of bytes completed will be returned. Return Value: Status code. --*/ { SYSTEM_CALL_PERFORM_VECTORED_IO Parameters; Parameters.Handle = Handle; Parameters.Flags = Flags; Parameters.TimeoutInMilliseconds = TimeoutInMilliseconds; Parameters.Offset = Offset; Parameters.Size = Size; Parameters.VectorArray = VectorArray; Parameters.VectorCount = VectorCount; OsSystemCall(SystemCallPerformVectoredIo, &Parameters); *BytesCompleted = Parameters.Size; return Parameters.Status; } OS_API KSTATUS OsFlush ( HANDLE Handle, ULONG Flags ) /*++ Routine Description: This routine flushes handle data to its backing device. If the flags specify that all data is to be flushed, then a handle is not required. Arguments: Handle - Supplies an open I/O handle. This parameter is not required if SYS_FLUSH_FLAG_ALL is set. Flags - Supplies a bitfield of flags. See SYS_FLUSH_FLAG_* definitions. Return Value: Status code. --*/ { SYSTEM_CALL_FLUSH Parameters; Parameters.Handle = Handle; Parameters.Flags = Flags; OsSystemCall(SystemCallFlush, &Parameters); return Parameters.Status; } OS_API KSTATUS OsCreatePipe ( HANDLE Directory, PSTR Path, ULONG PathLength, ULONG Flags, FILE_PERMISSIONS Permissions, PHANDLE ReadHandle, PHANDLE WriteHandle ) /*++ Routine Description: This routine creates a pipe. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies an optional pointer to the path to create the pipe at. PathLength - Supplies the length of the path buffer in bytes, including the null terminator character. Flags - Supplies a bitfield of flags governing the behavior of the new pipe descriptors. Only SYS_OPEN_FLAG_CLOSE_ON_EXECUTE and SYS_OPEN_FLAG_NON_BLOCKING are permitted. Permissions - Supplies the initial permissions to set on the pipe. ReadHandle - Supplies a pointer where the handle to the read end of the pipe will be returned on success. Handles are only returned if a NULL path was passed in. WriteHandle - Supplies a pointer where the handle to the write end of the pipe will be returned on success. Handles are only returned in a NULL path was passed in. Return Value: Status code. --*/ { SYSTEM_CALL_CREATE_PIPE Parameters; Parameters.Directory = Directory; Parameters.Path = Path; Parameters.PathLength = PathLength; Parameters.OpenFlags = Flags; Parameters.Permissions = Permissions; OsSystemCall(SystemCallCreatePipe, &Parameters); if (Path == NULL) { *ReadHandle = Parameters.ReadHandle; *WriteHandle = Parameters.WriteHandle; } return Parameters.Status; } OS_API VOID OsExitThread ( PVOID UnmapAddress, UINTN UnmapSize ) /*++ Routine Description: This routine terminates the current thread, and optionally attempts to unmap a region of memory on its way out. Usually this is the stack of the thread that is exiting. Arguments: UnmapAddress - Supplies an optional pointer to a region of memory to unmap as the thread exits. Supply NULL to skip unmapping. UnmapSize - Supplies the size of the region to unmap in bytes. This must be aligned to the page size. If it is not, the unmap simply won't happen. Supply 0 to skip the unmap and just exit the thread. If -1 is supplied, this routine returns. This value can be used to warm up the PLT entry, since lazy binding cannot take place after the thread's control block has been destroyed. Return Value: This routine does not return, unless the magic size is passed in. --*/ { if (UnmapSize == -1UL) { return; } OspExitThread(UnmapAddress, UnmapSize); } OS_API KSTATUS OsCreateThread ( PSTR ThreadName, ULONG ThreadNameBufferLength, PTHREAD_ENTRY_ROUTINE ThreadRoutine, PVOID Parameter, PVOID StackBase, ULONG StackSize, PVOID ThreadPointer, PTHREAD_ID ThreadId ) /*++ Routine Description: This routine creates a new thread. Arguments: ThreadName - Supplies an optional pointer to the thread name. ThreadNameBufferLength - Supplies the size of the thread name buffer, including the null terminator. ThreadRoutine - Supplies a pointer to the funtion that should be run on the new thread. Parameter - Supplies a pointer that will be passed directly to the thread routine. StackBase - Supplies an optional pointer to the stack base address. If supplied, the kernel will not add a guard region or automatically expand the stack. StackSize - Supplies the size of the new thread's stack. Supply 0 to use the system default. ThreadPointer - Supplies the thread pointer to set for the new thread. ThreadId - Supplies an optional pointer where the ID of the new thread will be returned on success. Return Value: Status code. --*/ { SYSTEM_CALL_CREATE_THREAD Parameters; Parameters.Name = ThreadName; Parameters.NameBufferLength = ThreadNameBufferLength; Parameters.ThreadRoutine = ThreadRoutine; Parameters.Parameter = Parameter; Parameters.StackBase = StackBase; Parameters.StackSize = StackSize; Parameters.ThreadPointer = ThreadPointer; Parameters.ThreadId = ThreadId; OsSystemCall(SystemCallCreateThread, &Parameters); return Parameters.Status; } OS_API KSTATUS OsForkProcess ( PPROCESS_ID NewProcessId ) /*++ Routine Description: This routine forks the current process into two separate processes. The child process begins executing in the middle of this function. Arguments: NewProcessId - Supplies a pointer that on success contains the process ID of the child process in the parent, and 0 in the child. This value contains -1 if the new process failed to spawn. Return Value: STATUS_SUCCESS in both the parent and child on success. Other status codes are returned to the parent if the child failed to spawn. --*/ { SYSTEM_CALL_FORK_PROCESS Parameters; // // If the call is successful, the child's parameter structure will not be // modified. Set the parameters up with the return values for the child // before making the call so that when the child returns, it looks like the // kernel filled those values in. // Parameters.Status = STATUS_SUCCESS; Parameters.ProcessId = 0; OspSystemCallFull(SystemCallForkProcess, &Parameters); *NewProcessId = Parameters.ProcessId; return Parameters.Status; } OS_API KSTATUS OsExecuteImage ( PPROCESS_ENVIRONMENT Environment ) /*++ Routine Description: This routine replaces the currently running process with the given binary image. Arguments: Environment - Supplies a pointer to the environment to execute, which includes the image name, parameters, and environment variables. Return Value: If this routine succeeds, it will not return, as the process will be replaced with the new executable. If the process could not be started, a failing status code will be returned to the caller. --*/ { SYSTEM_CALL_EXECUTE_IMAGE Parameters; RtlCopyMemory(&(Parameters.Environment), Environment, sizeof(PROCESS_ENVIRONMENT)); return OspSystemCallFull(SystemCallExecuteImage, &Parameters); } OS_API KSTATUS OsGetSystemVersion ( PSYSTEM_VERSION_INFORMATION VersionInformation, BOOL WantStrings ) /*++ Routine Description: This routine gets the system version information. Arguments: VersionInformation - Supplies a pointer where the system version information will be returned. The caller should not attempt to modify or free the strings pointed to by members of this structure. WantStrings - Supplies a boolean indicating if the build strings are desired or just the major/minor version information. Return Value: Status code. --*/ { UINTN BufferSize; ULONG EncodedVersion; PVOID HeapAllocation; PSYSTEM_VERSION_INFORMATION LocalInformation; KSTATUS Status; PUSER_SHARED_DATA UserSharedData; Status = STATUS_SUCCESS; // // Get the build strings from the kernel if needed. // if ((WantStrings != FALSE) && (OsProductName == NULL)) { BufferSize = 0; Status = OsGetSetSystemInformation(SystemInformationKe, KeInformationSystemVersion, NULL, &BufferSize, FALSE); ASSERT(Status == STATUS_BUFFER_TOO_SMALL); OsSystemVersionStringsSize = BufferSize; HeapAllocation = OsHeapAllocate(BufferSize, OS_VERSION_ALLOCATION_TAG); if (HeapAllocation == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto GetSystemVersionEnd; } Status = OsGetSetSystemInformation(SystemInformationKe, KeInformationSystemVersion, HeapAllocation, &BufferSize, FALSE); if (!KSUCCESS(Status)) { goto GetSystemVersionEnd; } LocalInformation = HeapAllocation; if (LocalInformation->BuildString != NULL) { LocalInformation->BuildString = (PVOID)((UINTN)LocalInformation + (UINTN)(LocalInformation->BuildString)); } if (LocalInformation->ProductName != NULL) { LocalInformation->ProductName = (PVOID)((UINTN)LocalInformation + (UINTN)(LocalInformation->ProductName)); } OsBuildString = LocalInformation->BuildString; OsProductName = LocalInformation->ProductName; } // // Fill in the caller's structure. // UserSharedData = OspGetUserSharedData(); EncodedVersion = UserSharedData->EncodedSystemVersion; VersionInformation->MajorVersion = DECODE_MAJOR_VERSION(EncodedVersion); VersionInformation->MinorVersion = DECODE_MINOR_VERSION(EncodedVersion); VersionInformation->Revision = DECODE_VERSION_REVISION(EncodedVersion); VersionInformation->SerialVersion = UserSharedData->SystemVersionSerial; VersionInformation->ReleaseLevel = DECODE_VERSION_RELEASE(EncodedVersion); VersionInformation->DebugLevel = DECODE_VERSION_DEBUG(EncodedVersion); VersionInformation->BuildTime.Seconds = UserSharedData->BuildTime; VersionInformation->BuildTime.Nanoseconds = 0; VersionInformation->ProductName = NULL; VersionInformation->BuildString = NULL; // // Copy the strings as well if requested. // if (WantStrings != FALSE) { VersionInformation->ProductName = OsProductName; VersionInformation->BuildString = OsBuildString; } Status = STATUS_SUCCESS; GetSystemVersionEnd: return Status; } OS_API KSTATUS OsGetCurrentDirectory ( BOOL Root, PSTR *Buffer, PUINTN BufferSize ) /*++ Routine Description: This routine retrieves a pointer to a null terminated string containing the path to the current working directory or the current root directory. Arguments: Root - Supplies a boolean indicating whether caller would like the current working directory (FALSE) or the path to the current root directory (TRUE). If the caller does not have permission to escape roots, or does not currently have an altered root directory, then / is returned. Buffer - Supplies a pointer that receives a pointer to a buffer that contains a null terminated string for the path to the current directory. BufferSize - Supplies a pointer that receives the size of the buffer, in bytes. Return Value: Status code. --*/ { PSTR CurrentDirectory; UINTN CurrentDirectorySize; ULONG Index; SYSTEM_CALL_GET_CURRENT_DIRECTORY Parameters; KSTATUS Status; CurrentDirectorySize = OS_GET_CURRENT_DIRECTORY_BUFFER_SIZE_GUESS; for (Index = 0; Index < OS_GET_CURRENT_DIRECTORY_TRY_COUNT; Index += 1) { CurrentDirectory = OsHeapAllocate(CurrentDirectorySize, OS_CURRENT_DIRECTORY_ALLOCATION_TAG); if (CurrentDirectory == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto GetCurrentDirectoryEnd; } Parameters.Root = Root; Parameters.Buffer = CurrentDirectory; Parameters.BufferSize = CurrentDirectorySize; OsSystemCall(SystemCallGetCurrentDirectory, &Parameters); // // Exit on any status besides a buffer too small result. // if (Parameters.Status != STATUS_BUFFER_TOO_SMALL) { break; } // // If the buffer is too small. Double the expected size just in case // another thread changes directories. // CurrentDirectorySize = Parameters.BufferSize * 2; OsHeapFree(CurrentDirectory); } Status = Parameters.Status; GetCurrentDirectoryEnd: if (KSUCCESS(Status)) { *Buffer = Parameters.Buffer; *BufferSize = Parameters.BufferSize; } else { OsHeapFree(CurrentDirectory); } return Parameters.Status; } OS_API KSTATUS OsChangeDirectory ( BOOL Root, PSTR Path, ULONG PathSize ) /*++ Routine Description: This routine sets the current working directory or current root directory. Arguments: Root - Supplies a boolean indicating whether to change the current working directory (FALSE) or the current root directory (TRUE). If attempting to change the root, the caller must have permission to change the root, must be running a single thread, and must not have any other handles to directories open. Path - Supplies a pointer to the path of the new working directory. If trying to escape the root, supply NULL here. The caller must have sufficient privileges to escape a root. PathSize - Supplies the size of the path directory string in bytes including the null terminator. Return Value: Status code. --*/ { SYSTEM_CALL_CHANGE_DIRECTORY Parameters; Parameters.Root = Root; Parameters.Buffer = Path; Parameters.BufferLength = PathSize; Parameters.Handle = INVALID_HANDLE; OsSystemCall(SystemCallChangeDirectory, &Parameters); return Parameters.Status; } OS_API KSTATUS OsChangeDirectoryHandle ( BOOL Root, HANDLE Handle ) /*++ Routine Description: This routine sets the current working directory or root directory to the same directory opened with the given file handle. Arguments: Root - Supplies a boolean indicating whether to change the current working directory (FALSE) or the current root directory (TRUE). If attempting to change the root, the caller must have permission to change the root, must be running a single thread, and must not have any other handles to directories open. Handle - Supplies an open handle to a directory to change the current working directroy to. Supply INVALID_HANDLE here to escape the root. The caller must have sufficient privileges to escape a root. Return Value: Status code. --*/ { SYSTEM_CALL_CHANGE_DIRECTORY Parameters; Parameters.Root = Root; Parameters.Buffer = NULL; Parameters.BufferLength = 0; Parameters.Handle = Handle; OsSystemCall(SystemCallChangeDirectory, &Parameters); return Parameters.Status; } OS_API KSTATUS OsPoll ( PSIGNAL_SET SignalMask, PPOLL_DESCRIPTOR Descriptors, ULONG DescriptorCount, ULONG TimeoutInMilliseconds, PULONG DescriptorsSelected ) /*++ Routine Description: This routine polls several I/O handles. Arguments: SignalMask - Supplies an optional pointer to a mask to set for the duration of the wait. Descriptors - Supplies a pointer to an array of poll descriptor structures describing the descriptors and events to wait on. DescriptorCount - Supplies the number of descriptors in the array. TimeoutInMilliseconds - Supplies the number of milliseconds to wait before giving up. DescriptorsSelected - Supplies a pointer where the number of descriptors that had activity will be returned on success. Return Value: STATUS_SUCCESS if one or more descriptors is ready for action. STATUS_INSUFFICIENT_RESOURCES if memory could not be allocated for the operation. STATUS_INTERRUPTED if a signal was caught during the wait. STATUS_TIMEOUT if no descriptors were ready in the given amount of time. --*/ { SYSTEM_CALL_POLL Poll; Poll.SignalMask = SignalMask; Poll.Descriptors = Descriptors; Poll.DescriptorCount = DescriptorCount; Poll.TimeoutInMilliseconds = TimeoutInMilliseconds; OsSystemCall(SystemCallPoll, &Poll); *DescriptorsSelected = Poll.DescriptorsSelected; return Poll.Status; } OS_API PSIGNAL_HANDLER_ROUTINE OsSetSignalHandler ( PSIGNAL_HANDLER_ROUTINE NewHandler ) /*++ Routine Description: This routine sets the signal handler routine called whenever a signal is delivered by the kernel. Arguments: NewHandler - Supplies a pointer to the new handler routine to use. Return Value: Returns a pointer to the old handler, or NULL if no other signal handlers were registered. --*/ { PSIGNAL_HANDLER_ROUTINE OldHandler; OldHandler = (PVOID)RtlAtomicExchange((PVOID)&OsSignalHandler, (UINTN)NewHandler); return OldHandler; } OS_API KSTATUS OsSendSignal ( SIGNAL_TARGET_TYPE TargetType, ULONG TargetId, ULONG SignalNumber, SHORT SignalCode, UINTN SignalParameter ) /*++ Routine Description: This routine sends a signal to a process, process group or thread. Arguments: TargetType - Supplies the target type to which the signal is being sent. It can be either a process, process group, or thread. TargetId - Supplies the ID for the signal's target process, process group, or thread. SignalNumber - Supplies the signal number to send. SignalCode - Supplies the signal code to send. See SIGNAL_CODE_* definitions. SignalParameter - Supplies a parameter to send with the signal if the signal is in the real time signal range. Return Value: Status code. --*/ { SYSTEM_CALL_SEND_SIGNAL SendSignal; SendSignal.TargetType = TargetType; SendSignal.TargetId = TargetId; SendSignal.SignalNumber = SignalNumber; SendSignal.SignalCode = SignalCode; SendSignal.SignalParameter = SignalParameter; // // Use the full system call because it makes debugging easier when // something like an abort gets forwarded to the kernel mode debugger. // OspSystemCallFull(SystemCallSendSignal, &SendSignal); return SendSignal.Status; } OS_API KSTATUS OsGetProcessId ( PROCESS_ID_TYPE ProcessIdType, PPROCESS_ID ProcessId ) /*++ Routine Description: This routine gets an identifier associated with the process, such as the process ID, thread ID, parent process ID, process group ID, and session ID. Arguments: ProcessIdType - Supplies the type of ID to get. ProcessId - Supplies a pointer that on input contains the process ID argument if the operation takes a parameter. On successful output, returns the desired ID. Supply zero to use the calling process ID. Return Value: Status code. --*/ { SYSTEM_CALL_GET_SET_PROCESS_ID Parameters; // // TODO: These values should be read once and cached, which means changing // the system call interface and then invalidating on fork. // Parameters.ProcessIdType = ProcessIdType; Parameters.ProcessId = *ProcessId; Parameters.NewValue = 0; Parameters.Set = FALSE; OsSystemCall(SystemCallGetSetProcessId, &Parameters); *ProcessId = Parameters.ProcessId; return Parameters.Status; } OS_API KSTATUS OsSetProcessId ( PROCESS_ID_TYPE ProcessIdType, PROCESS_ID ProcessId, PROCESS_ID NewValue ) /*++ Routine Description: This routine sets an identifier associated with the process, such as the process group ID or session ID. Arguments: ProcessIdType - Supplies the type of ID to set. Not all types can be set. ProcessId - Supplies the ID of the process to change. Supply 0 to use the current process. NewValue - Supplies the new value to set. Return Value: Status code. --*/ { SYSTEM_CALL_GET_SET_PROCESS_ID Parameters; Parameters.ProcessIdType = ProcessIdType; Parameters.ProcessId = ProcessId; Parameters.NewValue = NewValue; Parameters.Set = TRUE; OsSystemCall(SystemCallGetSetProcessId, &Parameters); return Parameters.Status; } OS_API SIGNAL_SET OsSetSignalBehavior ( SIGNAL_MASK_TYPE MaskType, SIGNAL_MASK_OPERATION Operation, PSIGNAL_SET NewMask ) /*++ Routine Description: This routine sets signal behavior, either for the current thread in the case of the blocked signals, or for the process for other signal masks. Arguments: MaskType - Supplies the type of mask to change. Operation - Supplies the interaction between the new mask and the previous signal mask. NewMask - Supplies a pointer to the mask of signals that are affected by this operation. Return Value: Returns the original signal mask before this function was called. --*/ { SYSTEM_CALL_SET_SIGNAL_BEHAVIOR SetSignalBehavior; SetSignalBehavior.MaskType = MaskType; SetSignalBehavior.Operation = Operation; if (NewMask != NULL) { SetSignalBehavior.SignalSet = *NewMask; } else { INITIALIZE_SIGNAL_SET(SetSignalBehavior.SignalSet); } OsSystemCall(SystemCallSetSignalBehavior, &SetSignalBehavior); return SetSignalBehavior.SignalSet; } OS_API KSTATUS OsWaitForChildProcess ( ULONG Flags, PPROCESS_ID ChildPid, PULONG Reason, PUINTN ChildExitValue, PRESOURCE_USAGE ChildResourceUsage ) /*++ Routine Description: This routine is called to suspend execution of the current thread until a child process completes. Arguments: Flags - Supplies a bitfield of flags governing the behavior of the wait. See SYSTEM_CALL_WAIT_FLAG_* definitions. ChildPid - Supplies a pointer that on input supplies the child process ID parameter. This parameter can be one of the following: If -1 is supplied, any child signal will be pulled off and returned. If a number greater than 0 is supplied, only the specific process ID will be pulled off and returned. If 0 is supplied, any child process whose process group ID is equal to that of the calling process will be pulled. If a number less than zero (but not -1) is supplied, then any process whose process group ID is equal to the absolute value of this parameter will be dequeued and returned. On output, this parameter will contain the process ID of the child that generated the signal activity, and the child signal will be discarded. If the wait for child parameter is set to FALSE, then this parameter is ignored. If a non-child signal cause the routine to return, then the value at this parameter is undefined. Reason - Supplies a pointer where the reason for the child event will be returned. See CHILD_SIGNAL_REASON_* definitions. ChildExitValue - Supplies a pointer where the child exit value (or signal that caused the event) will be returned. ChildResourceUsage - Supplies an optional pointer where the resource usage of the child will be returned on success. Return Value: STATUS_SUCCESS if the wait was successfully satisfied. If the SYSTEM_CALL_WAIT_FLAG_RETURN_IMMEDIATELY flag is set and there are no children ready to be reaped, then STATUS_SUCCESS is returned and the child PID is returned as -1. STATUS_INTERRUPTED if the wait was interrupted by a signal. STATUS_NO_ELIGIBLE_CHILDREN if no eligible children could be reaped. --*/ { SYSTEM_CALL_WAIT_FOR_CHILD Parameters; Parameters.Flags = Flags; Parameters.ChildPid = -1; if (ChildPid != NULL) { Parameters.ChildPid = *ChildPid; } Parameters.ResourceUsage = ChildResourceUsage; OsSystemCall(SystemCallWaitForChildProcess, &Parameters); if (ChildPid != NULL) { *ChildPid = Parameters.ChildPid; } if (Reason != NULL) { *Reason = Parameters.Reason; } if (ChildExitValue != NULL) { *ChildExitValue = Parameters.ChildExitValue; } return Parameters.Status; } OS_API KSTATUS OsSuspendExecution ( SIGNAL_MASK_OPERATION SignalOperation, PSIGNAL_SET SignalSet, PSIGNAL_PARAMETERS SignalParameters, ULONG TimeoutInMilliseconds ) /*++ Routine Description: This routine suspends execution of the current thread until a signal comes in. The current thread's blocked signal mask can be changed for the duration of the call by providing an operation and a signal set. Arguments: SignalOperation - Supplies the operation to perform with the signal set for the duration of the call: set, clear, overwrite or none. SignalSet - Supplies a pointer to the signal set to apply for the duration of this system call as dictated by the signal operation. SignalParameters - Supplies an optional pointer where the signal information for the signal that occurred will be returned. TimeoutInMilliseconds - Supplies the timeout of the operation in milliseconds. Return Value: STATUS_SUCCESS if a signal arrived. STATUS_INTERRUPTED on a clear signal operation if a signal that is not in the given set arrived. STATUS_TIMEOUT if no signal arrived before the given timeout expires. STATUS_INVALID_PARAMETER if no signal set is supplied for an operation other than SignalMaskOperationNone. --*/ { SYSTEM_CALL_SUSPEND_EXECUTION Parameters; if (SignalSet == NULL) { if (SignalOperation != SignalMaskOperationNone) { return STATUS_INVALID_PARAMETER; } } else { Parameters.SignalSet = *SignalSet; } Parameters.SignalOperation = SignalOperation; Parameters.SignalParameters = SignalParameters; Parameters.TimeoutInMilliseconds = TimeoutInMilliseconds; OsSystemCall(SystemCallSuspendExecution, &Parameters); return Parameters.Status; } OS_API NO_RETURN VOID OsExitProcess ( UINTN Status ) /*++ Routine Description: This routine terminates the current process and any threads that may be running in it. Arguments: Status - Supplies the exit status, returned to the parent in the wait calls. Conventionally 0 indicates success, and non-zero indicates failure. The C library only recieves the first eight bits of the return status, portable applications should not set bits beyond that. Return Value: This routine does not return. --*/ { SYSTEM_CALL_EXIT_PROCESS Parameters; Parameters.Status = Status; OsSystemCall(SystemCallExitProcess, &Parameters); while (TRUE) { ASSERT(FALSE); } } OS_API KSTATUS OsFileControl ( HANDLE Handle, FILE_CONTROL_COMMAND Command, PFILE_CONTROL_PARAMETERS_UNION Parameters ) /*++ Routine Description: This routine performs a file control operation on the given handle. Arguments: Handle - Supplies the file handle to operate on. Command - Supplies the command to perform. Parameters - Supplies an optional pointer to any additional parameters needed by the command. Return Value: Status code. --*/ { SYSTEM_CALL_FILE_CONTROL FileControl; FileControl.File = Handle; FileControl.Command = Command; FileControl.Parameters = Parameters; OsSystemCall(SystemCallFileControl, &FileControl); return FileControl.Status; } OS_API KSTATUS OsGetFileInformation ( HANDLE Directory, PSTR Path, ULONG PathLength, BOOL FollowLink, PFILE_PROPERTIES Properties ) /*++ Routine Description: This routine gets the file properties for a given file. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to the string containing the file path to get properties for. PathLength - Supplies the length of the path string in bytes including the null terminator. FollowLink - Supplies a boolean indicating what to do if the file path points to a symbolic link. If set to TRUE, the file information set or returned will be for the file the link points to. If FALSE, the call will set or get information for the link itself. Properties - Supplies a pointer where the file properties will be returned on success. Return Value: Status code. --*/ { SET_FILE_INFORMATION Request; KSTATUS Status; Request.FieldsToSet = 0; Status = OspGetSetFileInformation(Directory, Path, PathLength, FollowLink, &Request); if (KSUCCESS(Status)) { RtlCopyMemory(Properties, &(Request.FileProperties), sizeof(FILE_PROPERTIES)); } return Status; } OS_API KSTATUS OsSetFileInformation ( HANDLE Directory, PSTR Path, ULONG PathLength, BOOL FollowLink, PSET_FILE_INFORMATION Request ) /*++ Routine Description: This routine sets the file properties for a given file. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to the string containing the file path to set properties for. PathLength - Supplies the length of the path string in bytes including the null terminator. FollowLink - Supplies a boolean indicating what to do if the file path points to a symbolic link. If set to TRUE, the file information set or returned will be for the file the link points to. If FALSE, the call will set or get information for the link itself. Request - Supplies a pointer to the set file information request. Return Value: Status code. --*/ { KSTATUS Status; Status = OspGetSetFileInformation(Directory, Path, PathLength, FollowLink, Request); return Status; } OS_API VOID OsDebugPrint ( PSTR String, ULONG StringSize ) /*++ Routine Description: This routine prints a message to the debug console. No formatting is provided. Arguments: String - Supplies a pointer to the string to print. StringSize - Supplies the size of the string in bytes including the null terminator. Return Value: None. --*/ { OsDebug(DebugCommandPrint, 0, NULL, String, StringSize, 0); return; } OS_API KSTATUS OsDebug ( DEBUG_COMMAND_TYPE Command, PROCESS_ID Process, PVOID Address, PVOID Data, ULONG Size, ULONG SignalToDeliver ) /*++ Routine Description: This routine sends a debug command to a process. Arguments: Command - Supplies the command to send. Process - Supplies the process ID to send the command to. Address - Supplies the address parameter of the command, usually the address in the target to read from or write to. Data - Supplies the data parameter, usually the buffer containing the data to write or the buffer where the read data will be returned. Size - Supplies the size of the buffer, in bytes. SignalToDeliver - Supplies the signal number to deliver to the debugged process for step and continue commands. For other commands, this parameter is ignored. Return Value: Status code. --*/ { SYSTEM_CALL_DEBUG Request; Request.Command.Command = Command; Request.Process = Process; Request.Command.U.Address = Address; Request.Command.Data = Data; Request.Command.Size = Size; Request.Command.SignalToDeliver = SignalToDeliver; OsSystemCall(SystemCallDebug, &Request); return Request.Command.Status; } OS_API KSTATUS OsSeek ( HANDLE Handle, SEEK_COMMAND SeekCommand, IO_OFFSET Offset, PIO_OFFSET NewOffset ) /*++ Routine Description: This routine seeks to the given position in a file. This routine is only relevant for normal file or block based devices. Arguments: Handle - Supplies the open file handle. SeekCommand - Supplies the reference point for the seek offset. Usual reference points are the beginning of the file, current file position, and the end of the file. Offset - Supplies the offset from the reference point to move in bytes. NewOffset - Supplies an optional pointer where the file position after the move will be returned on success. Return Value: Status code. --*/ { SYSTEM_CALL_SEEK Request; Request.Handle = Handle; Request.Command = SeekCommand; Request.Offset = Offset; OsSystemCall(SystemCallSeek, &Request); if (NewOffset != NULL) { *NewOffset = Request.Offset; } return Request.Status; } OS_API KSTATUS OsCreateSymbolicLink ( HANDLE Directory, PSTR Path, ULONG PathSize, PSTR LinkDestinationBuffer, ULONG LinkDestinationBufferSize ) /*++ Routine Description: This routine creates a symbolic link. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to the symbolic link path. PathSize - Supplies the size of the symbolic link pointer in bytes including the null terminator. LinkDestinationBuffer - Supplies a pointer to a string containing the link's target path, the location the link points to. LinkDestinationBufferSize - Supplies the size of the link destination buffer in bytes, NOT including the null terminator. Return Value: Status code. --*/ { SYSTEM_CALL_CREATE_SYMBOLIC_LINK Parameters; Parameters.Directory = Directory; Parameters.Path = Path; Parameters.PathSize = PathSize; Parameters.LinkDestinationBuffer = LinkDestinationBuffer; Parameters.LinkDestinationBufferSize = LinkDestinationBufferSize; OsSystemCall(SystemCallCreateSymbolicLink, &Parameters); return Parameters.Status; } OS_API KSTATUS OsReadSymbolicLink ( HANDLE Directory, PSTR Path, ULONG PathSize, PSTR LinkDestinationBuffer, ULONG LinkDestinationBufferSize, PULONG LinkDestinationSize ) /*++ Routine Description: This routine reads the destination path of a symbolic link. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to the symbolic link path. PathSize - Supplies the size of the symbolic link pointer in bytes including the null terminator. LinkDestinationBuffer - Supplies a pointer to a buffer where the destination of the link will be returned. A null terminator byte is not written. LinkDestinationBufferSize - Supplies the size of the link destination buffer in bytes. LinkDestinationSize - Supplies a pointer where the actual size of the link destination (including the null terminator) will be returned on either success or a STATUS_BUFFER_TOO_SMALL case. On failure, 0 will be returned here. Return Value: STATUS_SUCCESS on success. STATUS_BUFFER_TOO_SMALL if the link destination buffer was not large enough to store the link destination. Other errors on other failures. --*/ { SYSTEM_CALL_READ_SYMBOLIC_LINK Parameters; Parameters.Directory = Directory; Parameters.Path = Path; Parameters.PathSize = PathSize; Parameters.LinkDestinationBuffer = LinkDestinationBuffer; Parameters.LinkDestinationBufferSize = LinkDestinationBufferSize; OsSystemCall(SystemCallReadSymbolicLink, &Parameters); *LinkDestinationSize = Parameters.LinkDestinationSize; return Parameters.Status; } OS_API KSTATUS OsCreateHardLink ( HANDLE ExistingFileDirectory, PSTR ExistingFile, ULONG ExistingFileSize, HANDLE LinkDirectory, PSTR LinkPath, ULONG LinkPathSize, BOOL FollowExistingFileLinks ) /*++ Routine Description: This routine creates a hard link. Arguments: ExistingFileDirectory - Supplies an optional handle to the directory to start path traversal from if the specified existing file path is relative. Supply INVALID_HANDLE here to use the current directory for relative paths. ExistingFile - Supplies a pointer to the path of the existing file to create the link from. ExistingFileSize - Supplies the size of the existing file path buffer in bytes, including the null terminator. LinkDirectory - Supplies an optional handle to the directory to start path traversal from if the specified new link path is relative. Supply INVALID_HANDLE here to use the current directory for relative paths. LinkPath - Supplies a pointer to a string containing the destination path of the new link. LinkPathSize - Supplies the size of the link path buffer in bytes. FollowExistingFileLinks - Supplies a boolean indicating that if the existing file path exists and is a symbolic link, the new link shall be for the target of that link (TRUE) rather than the link itself (FALSE). Return Value: Status code. --*/ { SYSTEM_CALL_CREATE_HARD_LINK Parameters; Parameters.ExistingFileDirectory = ExistingFileDirectory; Parameters.ExistingFilePath = ExistingFile; Parameters.ExistingFilePathSize = ExistingFileSize; Parameters.NewLinkDirectory = LinkDirectory; Parameters.NewLinkPath = LinkPath; Parameters.NewLinkPathSize = LinkPathSize; Parameters.FollowLinks = FollowExistingFileLinks; OsSystemCall(SystemCallCreateHardLink, &Parameters); return Parameters.Status; } OS_API KSTATUS OsDelete ( HANDLE Directory, PSTR Path, ULONG PathSize, ULONG Flags ) /*++ Routine Description: This routine attempts to delete the object at the given path. If the path points to a directory, the directory must be empty. If the path points to a file, the hard link count on the file is decremented. If the hard link count reaches zero and no processes have the file open, the contents of the file are destroyed. If processes have open handles to the file, the destruction of the file contents are deferred until the last handle to the old file is closed. If the path points to a symbolic link, the link itself is removed and not the destination. The removal of the entry from the directory is immediate. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to the path to delete. PathSize - Supplies the length of the path buffer in bytes, including the null terminator. Flags - Supplies flags associated with the delete operation. See SYS_DELETE_FLAG_* definitions. Return Value: Status code. --*/ { SYSTEM_CALL_DELETE Parameters; Parameters.Directory = Directory; Parameters.Path = Path; Parameters.PathSize = PathSize; Parameters.Flags = Flags; OsSystemCall(SystemCallDelete, &Parameters); return Parameters.Status; } OS_API KSTATUS OsRename ( HANDLE SourceDirectory, PSTR SourcePath, ULONG SourcePathSize, HANDLE DestinationDirectory, PSTR DestinationPath, ULONG DestinationPathSize ) /*++ Routine Description: This routine attempts to rename the object at the given path. This routine operates on symbolic links themselves, not the destinations of symbolic links. If the source and destination paths are equal, this routine will do nothing and return successfully. If the source path is not a directory, the destination path must not be a directory. If the destination file exists, it will be deleted. The caller must have write access in both the old and new directories. If the source path is a directory, the destination path must not exist or be an empty directory. The destination path must not have a path prefix of the source (ie it's illegal to move /my/path into /my/path/stuff). Arguments: SourceDirectory - Supplies an optional handle to the directory to start source path searches from. If the source path is absolute, this value is ignored. If this is INVALID_HANDLE, then source path searches will start from the current working directory. SourcePath - Supplies a pointer to the path of the file to rename. SourcePathSize - Supplies the length of the source path buffer in bytes, including the null terminator. DestinationDirectory - Supplies an optional handle to the directory to start destination path searches from. If the destination path is absolute, this value is ignored. If this is INVALID_HANDLE, then destination path searches will start from the current working directory. DestinationPath - Supplies a pointer to the path to rename the file to. DestinationPathSize - Supplies the size of the destination path buffer in bytes, including the null terminator. Return Value: Status code. --*/ { SYSTEM_CALL_RENAME Parameters; Parameters.SourceDirectory = SourceDirectory; Parameters.SourcePath = SourcePath; Parameters.SourcePathSize = SourcePathSize; Parameters.DestinationDirectory = DestinationDirectory; Parameters.DestinationPath = DestinationPath; Parameters.DestinationPathSize = DestinationPathSize; OsSystemCall(SystemCallRename, &Parameters); return Parameters.Status; } OS_API KSTATUS OsUserControl ( HANDLE Handle, ULONG RequestCode, PVOID Context, UINTN ContextSize ) /*++ Routine Description: This routine sends a user I/O request to the given file/device/etc. Arguments: Handle - Supplies the open file handle to send the request to. RequestCode - Supplies the request to send. For device handles, this is the minor code of the IRP. Context - Supplies a pointer to the context buffer allocated by the caller for the request. ContextSize - Supplies the size of the supplied context buffer. Return Value: Status code. --*/ { SYSTEM_CALL_USER_CONTROL Parameters; Parameters.Handle = Handle; Parameters.RequestCode = RequestCode; Parameters.Context = Context; Parameters.ContextSize = ContextSize; OsSystemCall(SystemCallUserControl, &Parameters); return Parameters.Status; } OS_API KSTATUS OsMount ( PSTR MountPointPath, ULONG MountPointPathSize, PSTR TargetPath, ULONG TargetPathSize, ULONG Flags ) /*++ Routine Description: This routine attempts to mount the given target at the given mount point. Arguments: MountPointPath - Supplies a pointer to a string containing the path to the mount point where the target is to be mounted. MountPointPathSize - Supplies the size of the mount point path string in bytes, including the null terminator. TargetPath - Supplies a pointer to a string containing the path to the target file, directory, volume, or device that is to be mounted. TargetPathSize - Supplies the size of the target path string in bytes, including the null terminator. Flags - Supplies the flags associated with the mount operation. See SYS_MOUNT_FLAG_* for definitions. Return Value: Status code. --*/ { KSTATUS Status; Flags &= ~SYS_MOUNT_FLAG_UNMOUNT; Status = OspMountOrUnmount(MountPointPath, MountPointPathSize, TargetPath, TargetPathSize, Flags); return Status; } OS_API KSTATUS OsUnmount ( PSTR MountPointPath, ULONG MountPointPathSize, ULONG Flags ) /*++ Routine Description: This routine attempts to unmount the given target. If the target is not a mount point, or the user does not have access to the mount point, then the routine will return the appropriate error. Otherwise, it will remove the mount point based on the supplied flags. Arguments: MountPointPath - Supplies a pointer to a string containing the path to the mount point that is to be unmounted. MountPointPathSize - Supplies the size of the mount point path string in bytes, including the null terminator. Flags - Supplies the flags associated with the mount operation. See SYS_MOUNT_FLAG_* for definitions. Return Value: Status code. --*/ { KSTATUS Status; Flags |= SYS_MOUNT_FLAG_UNMOUNT; Status = OspMountOrUnmount(MountPointPath, MountPointPathSize, NULL, 0, Flags); return Status; } OS_API KSTATUS OsGetMountPoints ( PVOID *Buffer, PUINTN BufferSize ) /*++ Routine Description: This routine returns the list of mount points currently in the system. It only returns the mounts that are visible to the calling process. The caller is responsible for releasing the buffer. Arguments: Buffer - Supplies a pointer that receives a buffer of mount point data. BufferSize - Supplies a pointer that receives the size of the mount point data. Return Value: Status code. --*/ { ULONG Index; PVOID MountPoints; UINTN MountPointsSize; KSTATUS Status; MountPointsSize = OS_GET_MOUNT_POINTS_BUFFER_SIZE_GUESS; for (Index = 0; Index < OS_GET_MOUNT_POINTS_TRY_COUNT; Index += 1) { MountPoints = OsHeapAllocate(MountPointsSize, OS_MOUNT_ALLOCATION_TAG); if (MountPoints == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto GetMountPointsEnd; } Status = OsGetSetSystemInformation(SystemInformationIo, IoInformationMountPoints, MountPoints, &MountPointsSize, FALSE); // // Exit on any status besides a buffer too small result. // if (Status != STATUS_BUFFER_TOO_SMALL) { break; } // // If the buffer is too small. Double the expected size just in case // something else sneaks in and try again. // MountPointsSize *= 2; OsHeapFree(MountPoints); } GetMountPointsEnd: if (KSUCCESS(Status)) { *Buffer = MountPoints; *BufferSize = MountPointsSize; } else { OsHeapFree(MountPoints); } return Status; } OS_API KSTATUS OsGetEffectiveAccess ( HANDLE Directory, PSTR Path, ULONG PathSize, ULONG DesiredFlags, BOOL UseRealIds, PULONG EffectiveAccess ) /*++ Routine Description: This routine determines the effective access for the given path. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths. Path - Supplies a pointer to a string containing the path to the object to query access of. PathSize - Supplies the size of the supplied path buffer in bytes including the null terminator. DesiredFlags - Supplies the bitfield of flags the user is interested in. See EFFECTIVE_ACCESS_* definitions. UseRealIds - Supplies a boolean indicating whether the access check should use the real user and group IDs (TRUE) or the effective user and group IDs (FALSE). EffectiveAccess - Supplies a pointer where the effective access permission bits are returned. Only bits set in the desired flags parameter will be potentially set. All other bits will be set to 0. See EFFECTIVE_ACCESS_* definitions. Return Value: Status code indicating if the request completed successfully. --*/ { SYSTEM_CALL_GET_EFFECTIVE_ACCESS Parameters; Parameters.Directory = Directory; Parameters.FilePath = Path; Parameters.FilePathSize = PathSize; Parameters.UseRealIds = UseRealIds; Parameters.DesiredFlags = DesiredFlags; Parameters.EffectiveAccess = 0; OsSystemCall(SystemCallGetEffectiveAccess, &Parameters); *EffectiveAccess = Parameters.EffectiveAccess; return Parameters.Status; } OS_API KSTATUS OsLoadDriver ( PSTR Path, ULONG PathSize ) /*++ Routine Description: This routine loads the given driver into kernel address space. Arguments: Path - Supplies a pointer to a string containing the path to the driver. PathSize - Supplies the size of the supplied path buffer in bytes including the null terminator. Return Value: Status code indicating if the request completed successfully. --*/ { SYSTEM_CALL_LOAD_DRIVER Parameters; Parameters.DriverName = Path; Parameters.DriverNameSize = PathSize; OsSystemCall(SystemCallLoadDriver, &Parameters); return Parameters.Status; } OS_API KSTATUS OsLocateDeviceInformation ( PUUID Uuid, PDEVICE_ID DeviceId, PDEVICE_INFORMATION_RESULT Results, PULONG ResultCount ) /*++ Routine Description: This routine returns instances of devices enumerating information. Callers can get all devices enumerating the given information type, or all information types enumerated by a given device. This routine must be called at low level. Arguments: Uuid - Supplies an optional pointer to the information identifier to filter on. If NULL, any information type will match. DeviceId - Supplies an optional pointer to the device ID to match against. If NULL, then any device will match. Results - Supplies a pointer to a caller allocated buffer where the results will be returned. ResultCount - Supplies a pointer that upon input contains the size of the buffer in information result elements. On output, returns the number of elements in the query, even if the provided buffer was too small. Do note however that the number of results can change between two successive searches. Return Value: STATUS_SUCCESS on success. STATUS_BUFFER_TOO_SMALL if the provided buffer was not large enough to contain all the results. The result count will contain the required number of elements to contain the results. --*/ { SYSTEM_CALL_LOCATE_DEVICE_INFORMATION Request; RtlZeroMemory(&Request, sizeof(SYSTEM_CALL_LOCATE_DEVICE_INFORMATION)); if (Uuid != NULL) { Request.ByUuid = TRUE; RtlCopyMemory(&(Request.Uuid), Uuid, sizeof(UUID)); } if (DeviceId != NULL) { Request.ByDeviceId = TRUE; Request.DeviceId = *DeviceId; } Request.Results = Results; Request.ResultCount = *ResultCount; OsSystemCall(SystemCallLocateDeviceInformation, &Request); *ResultCount = Request.ResultCount; return Request.Status; } OS_API KSTATUS OsGetSetDeviceInformation ( DEVICE_ID DeviceId, PUUID Uuid, PVOID Data, PUINTN DataSize, BOOL Set ) /*++ Routine Description: This routine gets or sets device information. Arguments: DeviceId - Supplies the device ID of the device to get or set information for. Uuid - Supplies a pointer to the identifier of the device information type to get or set. Data - Supplies a pointer to the data buffer that either contains the information to set or will contain the information to get on success. DataSize - Supplies a pointer that on input contains the size of the data buffer. On output contains the actual size of the data. Set - Supplies a boolean indicating whether to get information (FALSE) or set information (TRUE). Return Value: Status code. --*/ { SYSTEM_CALL_GET_SET_DEVICE_INFORMATION Request; RtlCopyMemory(&(Request.Uuid), Uuid, sizeof(UUID)); Request.DeviceId = DeviceId; Request.Data = Data; Request.DataSize = *DataSize; Request.Set = Set; OsSystemCall(SystemCallGetSetDeviceInformation, &Request); *DataSize = Request.DataSize; return Request.Status; } OS_API KSTATUS OsGetSetSystemInformation ( SYSTEM_INFORMATION_SUBSYSTEM Subsystem, UINTN InformationType, PVOID Data, PUINTN DataSize, BOOL Set ) /*++ Routine Description: This routine gets or sets system information. Arguments: Subsystem - Supplies the subsystem to query or set information of. InformationType - Supplies the information type, which is specific to the subsystem. The type of this value is generally _INFORMATION_TYPE (eg IO_INFORMATION_TYPE). Data - Supplies a pointer to the data buffer where the data is either returned for a get operation or given for a set operation. DataSize - Supplies a pointer that on input contains the size of the data buffer. On output, contains the required size of the data buffer. Set - Supplies a boolean indicating if this is a get operation (FALSE) or a set operation (TRUE). Return Value: STATUS_SUCCESS if the information was successfully queried or set. STATUS_BUFFER_TOO_SMALL if the buffer size specified was too small. The required buffer size will be returned in the data size parameter. STATUS_DATA_LENGTH_MISMATCH if the buffer size was not correct. The correct buffer size will be returned in the data size parameter. STATUS_INVALID_PARAMETER if the given subsystem or information type is not known. Other status codes on other failures. --*/ { SYSTEM_CALL_GET_SET_SYSTEM_INFORMATION Request; Request.Subsystem = Subsystem; Request.InformationType = InformationType; Request.Data = Data; Request.DataSize = *DataSize; Request.Set = Set; OsSystemCall(SystemCallGetSetSystemInformation, &Request); *DataSize = Request.DataSize; return Request.Status; } OS_API KSTATUS OsResetSystem ( SYSTEM_RESET_TYPE ResetType ) /*++ Routine Description: This routine attempts to reboot the system. Arguments: ResetType - Supplies the desired system reset type. If the given type is not supported and a cold reset is, then a cold reset will be performed. Return Value: STATUS_SUCCESS if the reset request was successfully queued. The process should expect to receive a termination signal shortly, followed by a kill signal shortly after that. STATUS_INVALID_PARAMETER if the given reset type is not valid. STATUS_INSUFFICIENT_RESOURCES if an allocation failure in the kernel prevented queuing of the reset system work item. --*/ { SYSTEM_CALL_RESET_SYSTEM Request; Request.ResetType = ResetType; OsSystemCall(SystemCallResetSystem, &Request); return Request.Status; } OS_API PVOID OsSetProgramBreak ( PVOID NewBreak ) /*++ Routine Description: This routine gets or sets the application program break for the process. Arguments: NewBreak - Supplies an optional pointer to the new break to set. If this is less than the original break, then no change is made. Set to NULL to simply get the current program break. Return Value: Returns the current program break, which is either the new value set or the previous value. --*/ { SYSTEM_CALL_SET_BREAK Request; Request.Break = NewBreak; OsSystemCall(SystemCallSetBreak, &Request); return Request.Break; } OS_API KSTATUS OsMemoryMap ( HANDLE Handle, IO_OFFSET Offset, UINTN Size, ULONG Flags, PVOID *Address ) /*++ Routine Description: This routine maps the specified object starting at the given offset for the requested size, in bytes. A suggested address can optionally be supplied. Arguments: Handle - Supplies a pointer to an opened I/O handle. Offset - Supplies the offset into the I/O object where the mapping should begin. Size - Supplies the size of the mapping region, in bytes. Flags - Supplies a bitfield of flags. See SYS_MAP_FLAG_* for definitions. Address - Supplies a pointer that receives the address of the mapped region. The caller can optionally specify a suggested address using this paramter. Return Value: Status code. --*/ { SYSTEM_CALL_MAP_UNMAP_MEMORY Parameters; Parameters.Map = TRUE; Parameters.Flags = Flags; Parameters.Handle = Handle; Parameters.Address = *Address; Parameters.Offset = Offset; Parameters.Size = Size; OsSystemCall(SystemCallMapOrUnmapMemory, &Parameters); if (KSUCCESS(Parameters.Status)) { *Address = Parameters.Address; } return Parameters.Status; } OS_API KSTATUS OsMemoryUnmap ( PVOID Address, UINTN Size ) /*++ Routine Description: This routine unmaps the specified region from the current process' address space. Arguments: Address - Supplies the starting address of the memory region to unmap. Size - Supplies the size of the region to unmap, in bytes. Return Value: Status code. --*/ { SYSTEM_CALL_MAP_UNMAP_MEMORY Parameters; Parameters.Map = FALSE; Parameters.Address = Address; Parameters.Size = Size; OsSystemCall(SystemCallMapOrUnmapMemory, &Parameters); return Parameters.Status; } OS_API KSTATUS OsSetMemoryProtection ( PVOID Address, UINTN Size, ULONG NewAttributes ) /*++ Routine Description: This routine set the memory protection attributes for the given region. Arguments: Address - Supplies the starting address (inclusive) to change the memory protection for. This must be aligned to a page boundary. Size - Supplies the length, in bytes, of the region to change attributes for. NewAttributes - Supplies the new attributes to set. See SYS_MAP_FLAG_* definitions. Return Value: Status code. --*/ { SYSTEM_CALL_SET_MEMORY_PROTECTION Parameters; Parameters.Address = Address; Parameters.Size = Size; Parameters.NewAttributes = NewAttributes; OsSystemCall(SystemCallSetMemoryProtection, &Parameters); return Parameters.Status; } OS_API KSTATUS OsMemoryFlush ( PVOID Address, ULONGLONG Size, ULONG Flags ) /*++ Routine Description: This routine flushes a region of the current process' mapped memory to permament storage, if the region has a backing image. Arguments: Address - Supplies the starting address of the memory region to synchronize. Size - Supplies the size of the region to synchronize, in bytes. Flags - Supplies a bitfield of flags. See SYS_MAP_SYNC_FLAG_* for definitions. Return Value: Status code. --*/ { SYSTEM_CALL_FLUSH_MEMORY Parameters; Parameters.Address = Address; Parameters.Size = Size; Parameters.Flags = Flags; OsSystemCall(SystemCallFlushMemory, &Parameters); return Parameters.Status; } OS_API KSTATUS OsSetThreadIdentity ( ULONG FieldsToSet, PTHREAD_IDENTITY Identity ) /*++ Routine Description: This routine gets or sets a thread's identity. Arguments: FieldsToSet - Supplies a bitfield indicating which identity fields to set. Supply zero to simply get the current thread identity. See THREAD_IDENTITY_FIELD_* definitions. Identity - Supplies a pointer that on input contains the thread identity fields to set. On successful output, will contain the complete new thread identity. Return Value: Status code. --*/ { SYSTEM_CALL_SET_THREAD_IDENTITY Parameters; Parameters.Request.FieldsToSet = FieldsToSet; if (FieldsToSet != 0) { RtlCopyMemory(&(Parameters.Request.Identity), Identity, sizeof(THREAD_IDENTITY)); } OsSystemCall(SystemCallSetThreadIdentity, &Parameters); if (KSUCCESS(Parameters.Status)) { RtlCopyMemory(Identity, &(Parameters.Request.Identity), sizeof(THREAD_IDENTITY)); } return Parameters.Status; } OS_API KSTATUS OsSetThreadPermissions ( ULONG FieldsToSet, PTHREAD_PERMISSIONS Permissions ) /*++ Routine Description: This routine gets or sets a thread's permission masks. Arguments: FieldsToSet - Supplies a bitfield indicating which permission sets or fields to modify. Supply zero to simply get the current thread permission sets. See THREAD_PERMISSION_FIELD_* definitions. Permissions - Supplies a pointer that on input contains the thread permission masks to set. On successful output, will contain the complete new set of permission masks. Return Value: Status code. --*/ { SYSTEM_CALL_SET_THREAD_PERMISSIONS Parameters; Parameters.Request.FieldsToSet = FieldsToSet; if (FieldsToSet != 0) { RtlCopyMemory(&(Parameters.Request.Permissions), Permissions, sizeof(THREAD_PERMISSIONS)); } OsSystemCall(SystemCallSetThreadPermissions, &Parameters); if (KSUCCESS(Parameters.Status)) { RtlCopyMemory(Permissions, &(Parameters.Request.Permissions), sizeof(THREAD_PERMISSIONS)); } return Parameters.Status; } OS_API KSTATUS OsSetSupplementaryGroups ( BOOL Set, PGROUP_ID Groups, PUINTN Count ) /*++ Routine Description: This routine gets or sets a thread's set of supplementary groups. To set the supplementary groups, the thread must have the set group ID permission. Arguments: Set - Supplies a boolean indicating whether to set the new groups (TRUE) or just get the current list of supplementary groups. Groups - Supplies a pointer that recieves the supplementary groups for a get operation or contains the new group IDs to set for a set operation. Count - Supplies a pointer that on input contains the number of elements in the given buffer. On output, contains the number of valid elements. If STATUS_BUFFER_TOO_SMALL is returned, the number of elements needed will be retunred. Return Value: STATUS_SUCCESS on success. STATUS_ACCESS_VIOLATION if the given groups buffer is invalid. STATUS_PERMISSION_DENIED if the caller does not have the set group ID permission. STATUS_INSUFFICIENT_RESOURCES if an internal kernel allocation failed. STATUS_INVALID_PARAMETER if the count was too big. STATUS_BUFFER_TOO_SMALL if the given buffer was not big enough to contain all the current supplementary groups. In this case, count contains the number of elements needed. --*/ { SYSTEM_CALL_SET_SUPPLEMENTARY_GROUPS Parameters; Parameters.Set = Set; Parameters.Groups = Groups; Parameters.Count = *Count; OsSystemCall(SystemCallSetSupplementaryGroups, &Parameters); *Count = Parameters.Count; return Parameters.Status; } OS_API KSTATUS OsSetResourceLimit ( RESOURCE_LIMIT_TYPE Type, PRESOURCE_LIMIT NewValue, PRESOURCE_LIMIT OldValue ) /*++ Routine Description: This routine gets or sets the current resource limit value for a given type. Arguments: Type - Supplies the resource limit type to get the limit for. NewValue - Supplies an optional pointer to the new limit to set. If this is NULL, then a new value is not set. OldValue - Supplies an optional pointer where the previous limit will be returned. Return Value: STATUS_SUCCESS on success. STATUS_INVALID_PARAMETER if the resource type is not valid or the current value was greater than the max. STATUS_PERMISSION_DENIED if the caller is trying to raise the max/hard limit and does not have the resources permission. --*/ { SYSTEM_CALL_SET_RESOURCE_LIMIT Parameters; Parameters.Type = Type; if (NewValue != NULL) { Parameters.Set = TRUE; Parameters.Value.Current = NewValue->Current; Parameters.Value.Max = NewValue->Max; } else { Parameters.Set = FALSE; } OsSystemCall(SystemCallSetResourceLimit, &Parameters); if (OldValue != NULL) { OldValue->Current = Parameters.Value.Current; OldValue->Max = Parameters.Value.Max; } return Parameters.Status; } OS_API KSTATUS OsCreateTerminal ( HANDLE MasterDirectory, HANDLE SlaveDirectory, PSTR MasterPath, UINTN MasterPathLength, PSTR SlavePath, UINTN SlavePathLength, ULONG MasterOpenFlags, FILE_PERMISSIONS MasterCreatePermissions, FILE_PERMISSIONS SlaveCreatePermissions, PHANDLE MasterHandle ) /*++ Routine Description: This routine creates a new pseudo-terminal master and slave at the given paths. Arguments: MasterDirectory - Supplies an optional handle to a directory for relative paths when creating the master. Supply INVALID_HANDLE to use the current working directory. SlaveDirectory - Supplies an optional handle to a directory for relative paths when creating the slave. Supply INVALID_HANDLE to use the current working directory. MasterPath - Supplies an optional pointer to the path to create for the master. MasterPathLength - Supplies the length of the master side path buffer in bytes, including the null terminator. SlavePath - Supplies an optional pointer to the path to create for the master. SlavePathLength - Supplies the length of the slave side path buffer in bytes, including the null terminator. MasterOpenFlags - Supplies the open flags to use when opening the master. Only read, write, and "no controlling terminal" flags are honored. MasterCreatePermissions - Supplies the permissions to apply to the created master side. SlaveCreatePermissions - Supplies the permission to apply to the created slave side. MasterHandle - Supplies a pointer where the opened handle to the master will be returned on success. Return Value: Status code. --*/ { SYSTEM_CALL_CREATE_TERMINAL Parameters; Parameters.MasterDirectory = MasterDirectory; Parameters.SlaveDirectory = SlaveDirectory; Parameters.MasterPath = MasterPath; Parameters.MasterPathLength = MasterPathLength; Parameters.SlavePath = SlavePath; Parameters.SlavePathLength = SlavePathLength; Parameters.MasterOpenFlags = MasterOpenFlags; Parameters.MasterCreatePermissions = MasterCreatePermissions; Parameters.SlaveCreatePermissions = SlaveCreatePermissions; OsSystemCall(SystemCallCreateTerminal, &Parameters); *MasterHandle = INVALID_HANDLE; if (KSUCCESS(Parameters.Status)) { *MasterHandle = Parameters.MasterHandle; } return Parameters.Status; } OS_API KSTATUS OsGetFilePath ( HANDLE Handle, PSTR Path, PUINTN PathSize ) /*++ Routine Description: This routine returns the file path for the given handle, if possible. Arguments: Handle - Supplies the open handle to get the file path of. Path - Supplies a pointer where the path will be returned on success. PathSize - Supplies a pointer that on input contains the size of the path buffer. On output, returns the needed size of the path buffer, even if the supplied buffer is too small. Return Value: STATUS_SUCCESS on success. STATUS_INVALID_HANDLE if the given handle is not valid. STATUS_PATH_NOT_FOUND if no path exists for the given handle. STATUS_BUFFER_TOO_SMALL if the supplied path buffer was not large enough to contain the complete path. In this case the path size returned is the size needed. STATUS_ACCESS_VIOLATION if the path buffer was invalid. --*/ { FILE_CONTROL_PARAMETERS_UNION Parameters; KSTATUS Status; Parameters.FilePath.Path = Path; Parameters.FilePath.PathSize = *PathSize; Status = OsFileControl(Handle, FileControlCommandGetPath, &Parameters); *PathSize = Parameters.FilePath.PathSize; return Status; } OS_API VOID OsSetThreadIdPointer ( PTHREAD_ID Pointer ) /*++ Routine Description: This routine sets the thread ID pointer in the kernel. If this value is non-null when the thread exits, then zero will be written to this address, and a UserLockWake operation will be performed to wake up one thread. Arguments: Pointer - Supplies the new user mode pointer to the thread ID that will be cleared when the thread exits. Supply NULL to clear the thread ID pointer in the kernel. If this is non-null, the kernel will write the thread ID into this region. Return Value: None. --*/ { SYSTEM_CALL_SET_THREAD_ID_POINTER Parameters; Parameters.Pointer = Pointer; OsSystemCall(SystemCallSetThreadIdPointer, &Parameters); return; } OS_API FILE_PERMISSIONS OsSetUmask ( FILE_PERMISSIONS NewMask ) /*++ Routine Description: This routine sets file permission mask for the current process. Bits set in this mask will be automatically cleared out of the permissions of any file or directory created. Arguments: NewMask - Supplies the new mask to set. Return Value: Returns the previously set mask. --*/ { SYSTEM_CALL_SET_UMASK Parameters; Parameters.Mask = NewMask; OsSystemCall(SystemCallSetUmask, &Parameters); return Parameters.Mask; } OS_API KSTATUS OsDuplicateHandle ( HANDLE ExistingHandle, PHANDLE NewHandle, ULONG Flags ) /*++ Routine Description: This routine duplicates a given handle at a new handle. Arguments: ExistingHandle - Supplies the handle to duplicate. NewHandle - Supplies a pointer that contains the destination handle value for the new handle. If this is INVALID_HANDLE, then the duplicated handle will be the lowest available handle value, and will be returned here. If this is not INVALID_HANDLE, then the previous handle at that location will be closed. If the new handle equals the existing handle, failure is returned. Flags - Supplies open flags to be set on the new handle. Only SYS_OPEN_FLAG_CLOSE_ON_EXECUTE is permitted. If not set, the new handle will have the close on execute flag cleared. Return Value: Status code. --*/ { SYSTEM_CALL_DUPLICATE_HANDLE Parameters; Parameters.OldHandle = ExistingHandle; Parameters.NewHandle = *NewHandle; Parameters.OpenFlags = Flags; OsSystemCall(SystemCallDuplicateHandle, &Parameters); *NewHandle = Parameters.NewHandle; return Parameters.Status; } VOID OspProcessSignal ( PSIGNAL_PARAMETERS Parameters, PSIGNAL_CONTEXT Context ) /*++ Routine Description: This routine processes a signal sent via the kernel. Arguments: Parameters - Supplies a pointer to the signal parameters from the kernel. Context - Supplies a pointer to the signal context from the kernel. Return Value: None. --*/ { BOOL RestartAllowed; PSIGNAL_HANDLER_ROUTINE SignalHandler; RestartAllowed = FALSE; SignalHandler = OsSignalHandler; if (SignalHandler != NULL) { RestartAllowed = SignalHandler(Parameters); } // // Clear the restart flag if it's set but the handler does not allow // restarts. // if (((Context->Flags & SIGNAL_CONTEXT_FLAG_RESTART) != 0) && (RestartAllowed == FALSE)) { Context->Flags &= ~SIGNAL_CONTEXT_FLAG_RESTART; } return; } // // --------------------------------------------------------- Internal Functions // PVOID OspSetSignalHandler ( PVOID SignalHandlerRoutine ) /*++ Routine Description: This routine sets the signal handler routine for the given thread. Arguments: SignalHandlerRoutine - Supplies a pointer to the signal handler routine to invoke when signals occur. The two parameters to the routine will be the signal number and the optional parameter, both of which will be passed via registers. Return Value: Returns a pointer to the original signal handler registered, or NULL if no signal handler was previously registered. --*/ { SYSTEM_CALL_SET_SIGNAL_HANDLER Parameters; Parameters.SignalHandler = SignalHandlerRoutine; OsSystemCall(SystemCallSetSignalHandler, &Parameters); return Parameters.SignalHandler; } KSTATUS OspGetSetFileInformation ( HANDLE Directory, PSTR Path, ULONG PathSize, BOOL FollowLink, PSET_FILE_INFORMATION Request ) /*++ Routine Description: This routine gets or sets the file properties for a given file. Arguments: Directory - Supplies an optional handle to a directory to start the search from if the supplied path is relative. Supply INVALID_HANDLE here to to use the current directory for relative paths (usually the expected default). Path - Supplies a pointer to the string containing the file path to get or set properties for. PathSize - Supplies the size of the path string in bytes including the null terminator. FollowLink - Supplies a boolean indicating what to do if the file path points to a symbolic link. If set to TRUE, the file information set or returned will be for the file the link points to. If FALSE, the call will set or get information for the link itself. Request - Supplies a pointer to the get or set file properties request. Return Value: Status code. --*/ { SYSTEM_CALL_GET_SET_FILE_INFORMATION Parameters; Parameters.Request.FieldsToSet = 0; if (Request->FieldsToSet != 0) { RtlCopyMemory(&(Parameters.Request), Request, sizeof(SET_FILE_INFORMATION)); } Parameters.Directory = Directory; Parameters.FilePath = Path; Parameters.FilePathSize = PathSize; Parameters.FollowLink = FollowLink; OsSystemCall(SystemCallGetSetFileInformation, &Parameters); if (Request->FieldsToSet == 0) { RtlCopyMemory(Request, &(Parameters.Request), sizeof(SET_FILE_INFORMATION)); } return Parameters.Status; } KSTATUS OspMountOrUnmount ( PSTR MountPointPath, ULONG MountPointPathSize, PSTR TargetPath, ULONG TargetPathSize, ULONG Flags ) /*++ Routine Description: This routine mounts the target at the given mount point or unmounts the mount point. Arguments: MountPointPath - Supplies a pointer to a string containing the path to the mount point where the target is to be mounted. MountPointPathSize - Supplies the size of the mount point path string in bytes, including the null terminator. TargetPath - Supplies a pointer to a string containing the path to the target file, directory, volume, or device that is to be mounted. TargetPathSize - Supplies the size of the target path string in bytes, including the null terminator. Flags - Supplies the flags associated with the mount operation. See SYS_MOUNT_FLAG_* for definitions. Return Value: Status code. --*/ { SYSTEM_CALL_MOUNT_UNMOUNT Parameters; // // Make the system call with the mount/unmount information. // Parameters.MountPointPath = MountPointPath; Parameters.MountPointPathSize = MountPointPathSize; Parameters.TargetPath = TargetPath; Parameters.TargetPathSize = TargetPathSize; Parameters.Flags = Flags; OsSystemCall(SystemCallMountOrUnmount, &Parameters); return Parameters.Status; } NO_RETURN VOID OspExitThread ( PVOID UnmapAddress, UINTN UnmapSize ) /*++ Routine Description: This routine terminates the current thread, and optionally attempts to unmap a region of memory on its way out. Usually this is the stack of the thread that is exiting. Arguments: UnmapAddress - Supplies an optional pointer to a region of memory to unmap as the thread exits. Supply NULL to skip unmapping. UnmapSize - Supplies the size of the region to unmap in bytes. This must be aligned to the page size. If it is not, the unmap simply won't happen. Supply 0 to skip the unmap and just exit the thread. Return Value: This routine does not return. --*/ { SYSTEM_CALL_EXIT_THREAD Parameters; Parameters.UnmapAddress = UnmapAddress; Parameters.UnmapSize = UnmapSize; OsSystemCall(SystemCallExitThread, &Parameters); while (TRUE) { ASSERT(FALSE); } }