dlls/ntdll/unixlib.h

   1 /*
   2  * Ntdll Unix interface
   3  *
   4  * Copyright (C) 2020 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __NTDLL_UNIXLIB_H
  22 #define __NTDLL_UNIXLIB_H
  23
  24 #include "wine/server.h"
  25 #include "wine/debug.h"
  26
  27 struct msghdr;
  28 struct _DISPATCHER_CONTEXT;
  29
  30 /* increment this when you change the function table */
  31 #define NTDLL_UNIXLIB_VERSION 71
  32
  33 struct unix_funcs
  34 {
  35     /* Nt* functions */
  36     NTSTATUS      (WINAPI *NtAlertResumeThread)( HANDLE handle, ULONG *count );
  37     NTSTATUS      (WINAPI *NtAlertThread)( HANDLE handle );
  38     NTSTATUS      (WINAPI *NtAllocateVirtualMemory)( HANDLE process, PVOID *ret, ULONG_PTR zero_bits,
  39                                                      SIZE_T *size_ptr, ULONG type, ULONG protect );
  40     NTSTATUS      (WINAPI *NtAreMappedFilesTheSame)(PVOID addr1, PVOID addr2);
  41     NTSTATUS      (WINAPI *NtAssignProcessToJobObject)( HANDLE job, HANDLE process );
  42     NTSTATUS      (WINAPI *NtCancelTimer)( HANDLE handle, BOOLEAN *state );
  43     NTSTATUS      (WINAPI *NtClearEvent)( HANDLE handle );
  44     NTSTATUS      (WINAPI *NtClose)( HANDLE handle );
  45     NTSTATUS      (WINAPI *NtContinue)( CONTEXT *context, BOOLEAN alertable );
  46     NTSTATUS      (WINAPI *NtCreateEvent)( HANDLE *handle, ACCESS_MASK access,
  47                                            const OBJECT_ATTRIBUTES *attr, EVENT_TYPE type, BOOLEAN state );
  48     NTSTATUS      (WINAPI *NtCreateIoCompletion)( HANDLE *handle, ACCESS_MASK access,
  49                                                   OBJECT_ATTRIBUTES *attr, ULONG threads );
  50     NTSTATUS      (WINAPI *NtCreateJobObject)( HANDLE *handle, ACCESS_MASK access,
  51                                                const OBJECT_ATTRIBUTES *attr );
  52     NTSTATUS      (WINAPI *NtCreateKeyedEvent)( HANDLE *handle, ACCESS_MASK access,
  53                                                 const OBJECT_ATTRIBUTES *attr, ULONG flags );
  54     NTSTATUS      (WINAPI *NtCreateMailslotFile)( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
  55                                                   IO_STATUS_BLOCK *io, ULONG options, ULONG quota,
  56                                                   ULONG msg_size, LARGE_INTEGER *timeout );
  57     NTSTATUS      (WINAPI *NtCreateMutant)( HANDLE *handle, ACCESS_MASK access,
  58                                             const OBJECT_ATTRIBUTES *attr, BOOLEAN owned );
  59     NTSTATUS      (WINAPI *NtCreateNamedPipeFile)( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
  60                                                    IO_STATUS_BLOCK *io, ULONG sharing, ULONG dispo,
  61                                                    ULONG options, ULONG pipe_type, ULONG read_mode,
  62                                                    ULONG completion_mode, ULONG max_inst,
  63                                                    ULONG inbound_quota, ULONG outbound_quota,
  64                                                    LARGE_INTEGER *timeout );
  65     NTSTATUS      (WINAPI *NtCreateSection)( HANDLE *handle, ACCESS_MASK access,
  66                                              const OBJECT_ATTRIBUTES *attr, const LARGE_INTEGER *size,
  67                                              ULONG protect, ULONG sec_flags, HANDLE file );
  68     NTSTATUS      (WINAPI *NtCreateSemaphore)( HANDLE *handle, ACCESS_MASK access,
  69                                                const OBJECT_ATTRIBUTES *attr, LONG initial, LONG max );
  70     NTSTATUS      (WINAPI *NtCreateThreadEx)( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
  71                                               HANDLE process, PRTL_THREAD_START_ROUTINE start, void *param,
  72                                               ULONG flags, SIZE_T zero_bits, SIZE_T stack_commit,
  73                                               SIZE_T stack_reserve, PS_ATTRIBUTE_LIST *attr_list );
  74     NTSTATUS      (WINAPI *NtCreateTimer)( HANDLE *handle, ACCESS_MASK access,
  75                                            const OBJECT_ATTRIBUTES *attr, TIMER_TYPE type );
  76     NTSTATUS      (WINAPI *NtCreateUserProcess)( HANDLE *process_handle_ptr, HANDLE *thread_handle_ptr,
  77                                                  ACCESS_MASK process_access, ACCESS_MASK thread_access,
  78                                                  OBJECT_ATTRIBUTES *process_attr, OBJECT_ATTRIBUTES *thread_attr,
  79                                                  ULONG process_flags, ULONG thread_flags,
  80                                                  RTL_USER_PROCESS_PARAMETERS *params, PS_CREATE_INFO *info,
  81                                                  PS_ATTRIBUTE_LIST *attr );
  82     TEB *         (WINAPI *NtCurrentTeb)(void);
  83     NTSTATUS      (WINAPI *NtDelayExecution)( BOOLEAN alertable, const LARGE_INTEGER *timeout );
  84     NTSTATUS      (WINAPI *NtDeleteFile)( OBJECT_ATTRIBUTES *attr );
  85     NTSTATUS      (WINAPI *NtDeviceIoControlFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
  86                                                    void *apc_context, IO_STATUS_BLOCK *io, ULONG code,
  87                                                    void *in_buffer, ULONG in_size,
  88                                                    void *out_buffer, ULONG out_size );
  89     NTSTATUS      (WINAPI *NtDuplicateObject)( HANDLE source_process, HANDLE source,
  90                                                HANDLE dest_process, HANDLE *dest,
  91                                                ACCESS_MASK access, ULONG attributes, ULONG options );
  92     NTSTATUS      (WINAPI *NtFlushBuffersFile)( HANDLE handle, IO_STATUS_BLOCK *io );
  93     NTSTATUS      (WINAPI *NtFlushInstructionCache)( HANDLE handle, const void *addr, SIZE_T size );
  94     void          (WINAPI *NtFlushProcessWriteBuffers)(void);
  95     NTSTATUS      (WINAPI *NtFlushVirtualMemory)( HANDLE process, LPCVOID *addr_ptr,
  96                                                   SIZE_T *size_ptr, ULONG unknown );
  97     NTSTATUS      (WINAPI *NtFreeVirtualMemory)( HANDLE process, PVOID *addr_ptr,
  98                                                  SIZE_T *size_ptr, ULONG type );
  99     NTSTATUS      (WINAPI *NtFsControlFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 100                                              void *apc_context, IO_STATUS_BLOCK *io, ULONG code,
 101                                              void *in_buffer, ULONG in_size,
 102                                              void *out_buffer, ULONG out_size );
 103     NTSTATUS      (WINAPI *NtGetContextThread)( HANDLE handle, CONTEXT *context );
 104     ULONG         (WINAPI *NtGetCurrentProcessorNumber)(void);
 105     NTSTATUS      (WINAPI *NtGetWriteWatch)( HANDLE process, ULONG flags, PVOID base, SIZE_T size,
 106                                              PVOID *addresses, ULONG_PTR *count, ULONG *granularity );
 107     NTSTATUS      (WINAPI *NtIsProcessInJob)( HANDLE process, HANDLE job );
 108     NTSTATUS      (WINAPI *NtLockVirtualMemory)( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown );
 109     NTSTATUS      (WINAPI *NtMapViewOfSection)( HANDLE handle, HANDLE process, PVOID *addr_ptr,
 110                                                 ULONG_PTR zero_bits, SIZE_T commit_size,
 111                                                 const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr,
 112                                                 SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect );
 113     NTSTATUS      (WINAPI *NtNotifyChangeDirectoryFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 114                                                          void *apc_context, IO_STATUS_BLOCK *iosb,
 115                                                          void *buffer, ULONG buffer_size,
 116                                                          ULONG filter, BOOLEAN subtree );
 117     NTSTATUS      (WINAPI *NtOpenEvent)( HANDLE *handle, ACCESS_MASK access,
 118                                          const OBJECT_ATTRIBUTES *attr );
 119     NTSTATUS      (WINAPI *NtOpenIoCompletion)( HANDLE *handle, ACCESS_MASK access,
 120                                                 const OBJECT_ATTRIBUTES *attr );
 121     NTSTATUS      (WINAPI *NtOpenJobObject)( HANDLE *handle, ACCESS_MASK access,
 122                                              const OBJECT_ATTRIBUTES *attr );
 123     NTSTATUS      (WINAPI *NtOpenKeyedEvent)( HANDLE *handle, ACCESS_MASK access,
 124                                               const OBJECT_ATTRIBUTES *attr );
 125     NTSTATUS      (WINAPI *NtOpenMutant)( HANDLE *handle, ACCESS_MASK access,
 126                                           const OBJECT_ATTRIBUTES *attr );
 127     NTSTATUS      (WINAPI *NtOpenProcess)( HANDLE *handle, ACCESS_MASK access,
 128                                            const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id );
 129     NTSTATUS      (WINAPI *NtOpenSection)( HANDLE *handle, ACCESS_MASK access,
 130                                            const OBJECT_ATTRIBUTES *attr );
 131     NTSTATUS      (WINAPI *NtOpenSemaphore)( HANDLE *handle, ACCESS_MASK access,
 132                                              const OBJECT_ATTRIBUTES *attr );
 133     NTSTATUS      (WINAPI *NtOpenThread)( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id );
 134     NTSTATUS      (WINAPI *NtOpenTimer)( HANDLE *handle, ACCESS_MASK access,
 135                                          const OBJECT_ATTRIBUTES *attr );
 136     NTSTATUS      (WINAPI *NtPowerInformation)( POWER_INFORMATION_LEVEL level, void *input, ULONG in_size,
 137                                                 void *output, ULONG out_size );
 138     NTSTATUS      (WINAPI *NtProtectVirtualMemory)( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr,
 139                                                     ULONG new_prot, ULONG *old_prot );
 140     NTSTATUS      (WINAPI *NtPulseEvent)( HANDLE handle, LONG *prev_state );
 141     NTSTATUS      (WINAPI *NtQueryAttributesFile)( const OBJECT_ATTRIBUTES *attr,
 142                                                    FILE_BASIC_INFORMATION *info );
 143     NTSTATUS      (WINAPI *NtQueryDirectoryFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine,
 144                                                   void *apc_context, IO_STATUS_BLOCK *io, void *buffer,
 145                                                   ULONG length, FILE_INFORMATION_CLASS info_class,
 146                                                   BOOLEAN single_entry, UNICODE_STRING *mask,
 147                                                   BOOLEAN restart_scan );
 148     NTSTATUS      (WINAPI *NtQueryEvent)( HANDLE handle, EVENT_INFORMATION_CLASS class,
 149                                           void *info, ULONG len, ULONG *ret_len );
 150     NTSTATUS      (WINAPI *NtQueryFullAttributesFile)( const OBJECT_ATTRIBUTES *attr,
 151                                                        FILE_NETWORK_OPEN_INFORMATION *info );
 152     NTSTATUS      (WINAPI *NtQueryInformationFile)( HANDLE hFile, IO_STATUS_BLOCK *io,
 153                                                     void *ptr, LONG len, FILE_INFORMATION_CLASS class );
 154     NTSTATUS      (WINAPI *NtQueryInformationJobObject)( HANDLE handle, JOBOBJECTINFOCLASS class,
 155                                                          void *info, ULONG len, ULONG *ret_len );
 156     NTSTATUS      (WINAPI *NtQueryInformationProcess)( HANDLE handle, PROCESSINFOCLASS class, void *info,
 157                                                        ULONG size, ULONG *ret_len );
 158     NTSTATUS      (WINAPI *NtQueryInformationThread)( HANDLE handle, THREADINFOCLASS class,
 159                                                       void *data, ULONG length, ULONG *ret_len );
 160     NTSTATUS      (WINAPI *NtQueryIoCompletion)( HANDLE handle, IO_COMPLETION_INFORMATION_CLASS class,
 161                                                  void *buffer, ULONG len, ULONG *ret_len );
 162     NTSTATUS      (WINAPI *NtQueryMutant)( HANDLE handle, MUTANT_INFORMATION_CLASS class,
 163                                            void *info, ULONG len, ULONG *ret_len );
 164     NTSTATUS      (WINAPI *NtQueryPerformanceCounter)( LARGE_INTEGER *counter, LARGE_INTEGER *frequency );
 165     NTSTATUS      (WINAPI *NtQuerySection)( HANDLE handle, SECTION_INFORMATION_CLASS class,
 166                                             void *ptr, SIZE_T size, SIZE_T *ret_size );
 167     NTSTATUS      (WINAPI *NtQuerySemaphore)( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
 168                                               void *info, ULONG len, ULONG *ret_len );
 169     NTSTATUS      (WINAPI *NtQuerySystemInformation)( SYSTEM_INFORMATION_CLASS class,
 170                                                       void *info, ULONG size, ULONG *ret_size );
 171     NTSTATUS      (WINAPI *NtQuerySystemInformationEx)( SYSTEM_INFORMATION_CLASS class,
 172                                                         void *query, ULONG query_len,
 173                                                         void *info, ULONG size, ULONG *ret_size );
 174     NTSTATUS      (WINAPI *NtQuerySystemTime)( LARGE_INTEGER *time );
 175     NTSTATUS      (WINAPI *NtQueryTimer)( HANDLE handle, TIMER_INFORMATION_CLASS class,
 176                                           void *info, ULONG len, ULONG *ret_len );
 177     NTSTATUS      (WINAPI *NtQueryVirtualMemory)( HANDLE process, LPCVOID addr,
 178                                                   MEMORY_INFORMATION_CLASS info_class,
 179                                                   PVOID buffer, SIZE_T len, SIZE_T *res_len );
 180     NTSTATUS      (WINAPI *NtQueryVolumeInformationFile)( HANDLE handle, IO_STATUS_BLOCK *io,
 181                                                           void *buffer, ULONG length,
 182                                                           FS_INFORMATION_CLASS info_class );
 183     NTSTATUS      (WINAPI *NtQueueApcThread)( HANDLE handle, PNTAPCFUNC func, ULONG_PTR arg1,
 184                                               ULONG_PTR arg2, ULONG_PTR arg3 );
 185     NTSTATUS      (WINAPI *NtRaiseException)( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance );
 186     NTSTATUS      (WINAPI *NtReadFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
 187                                         IO_STATUS_BLOCK *io, void *buffer, ULONG length,
 188                                         LARGE_INTEGER *offset, ULONG *key );
 189     NTSTATUS      (WINAPI *NtReadFileScatter)( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc,
 190                                                void *apc_user, IO_STATUS_BLOCK *io,
 191                                                FILE_SEGMENT_ELEMENT *segments, ULONG length,
 192                                                LARGE_INTEGER *offset, ULONG *key );
 193     NTSTATUS      (WINAPI *NtReadVirtualMemory)( HANDLE process, const void *addr, void *buffer,
 194                                                  SIZE_T size, SIZE_T *bytes_read );
 195     NTSTATUS      (WINAPI *NtReleaseKeyedEvent)( HANDLE handle, const void *key,
 196                                                  BOOLEAN alertable, const LARGE_INTEGER *timeout );
 197     NTSTATUS      (WINAPI *NtReleaseMutant)( HANDLE handle, LONG *prev_count );
 198     NTSTATUS      (WINAPI *NtReleaseSemaphore)( HANDLE handle, ULONG count, ULONG *previous );
 199     NTSTATUS      (WINAPI *NtRemoveIoCompletion)( HANDLE handle, ULONG_PTR *key, ULONG_PTR *value,
 200                                                   IO_STATUS_BLOCK *io, LARGE_INTEGER *timeout );
 201     NTSTATUS      (WINAPI *NtRemoveIoCompletionEx)( HANDLE handle, FILE_IO_COMPLETION_INFORMATION *info,
 202                                                     ULONG count, ULONG *written,
 203                                                     LARGE_INTEGER *timeout, BOOLEAN alertable );
 204     NTSTATUS      (WINAPI *NtResetEvent)( HANDLE handle, LONG *prev_state );
 205     NTSTATUS      (WINAPI *NtResetWriteWatch)( HANDLE process, PVOID base, SIZE_T size );
 206     NTSTATUS      (WINAPI *NtResumeProcess)( HANDLE handle );
 207     NTSTATUS      (WINAPI *NtResumeThread)( HANDLE handle, ULONG *count );
 208     NTSTATUS      (WINAPI *NtSetContextThread)( HANDLE handle, const CONTEXT *context );
 209     NTSTATUS      (WINAPI *NtSetEvent)( HANDLE handle, LONG *prev_state );
 210     NTSTATUS      (WINAPI *NtSetInformationFile)( HANDLE handle, IO_STATUS_BLOCK *io,
 211                                                   void *ptr, ULONG len, FILE_INFORMATION_CLASS class );
 212     NTSTATUS      (WINAPI *NtSetInformationJobObject)( HANDLE handle, JOBOBJECTINFOCLASS class,
 213                                                        void *info, ULONG len );
 214     NTSTATUS      (WINAPI *NtSetInformationProcess)( HANDLE handle, PROCESSINFOCLASS class,
 215                                                      void *info, ULONG size );
 216     NTSTATUS      (WINAPI *NtSetInformationThread)( HANDLE handle, THREADINFOCLASS class,
 217                                                     const void *data, ULONG length );
 218     NTSTATUS      (WINAPI *NtSetIoCompletion)( HANDLE handle, ULONG_PTR key, ULONG_PTR value,
 219                                                NTSTATUS status, SIZE_T count );
 220     NTSTATUS      (WINAPI *NtSetLdtEntries)( ULONG sel1, LDT_ENTRY entry1, ULONG sel2, LDT_ENTRY entry2 );
 221     NTSTATUS      (WINAPI *NtSetSystemTime)( const LARGE_INTEGER *new, LARGE_INTEGER *old );
 222     NTSTATUS      (WINAPI *NtSetTimer)( HANDLE handle, const LARGE_INTEGER *when,
 223                                         PTIMER_APC_ROUTINE callback, void *arg,
 224                                         BOOLEAN resume, ULONG period, BOOLEAN *state );
 225     NTSTATUS      (WINAPI *NtSetVolumeInformationFile)( HANDLE handle, IO_STATUS_BLOCK *io, void *info,
 226                                                         ULONG length, FS_INFORMATION_CLASS class );
 227     NTSTATUS      (WINAPI *NtSignalAndWaitForSingleObject)( HANDLE signal, HANDLE wait,
 228                                                             BOOLEAN alertable, const LARGE_INTEGER *timeout );
 229     NTSTATUS      (WINAPI *NtSuspendProcess)( HANDLE handle );
 230     NTSTATUS      (WINAPI *NtSuspendThread)( HANDLE handle, ULONG *count );
 231     NTSTATUS      (WINAPI *NtTerminateJobObject)( HANDLE handle, NTSTATUS status );
 232     NTSTATUS      (WINAPI *NtTerminateProcess)( HANDLE handle, LONG exit_code );
 233     NTSTATUS      (WINAPI *NtTerminateThread)( HANDLE handle, LONG exit_code );
 234     NTSTATUS      (WINAPI *NtUnlockVirtualMemory)( HANDLE process, PVOID *addr,
 235                                                    SIZE_T *size, ULONG unknown );
 236     NTSTATUS      (WINAPI *NtUnmapViewOfSection)( HANDLE process, PVOID addr );
 237     NTSTATUS      (WINAPI *NtWaitForKeyedEvent)( HANDLE handle, const void *key, BOOLEAN alertable,
 238                                                  const LARGE_INTEGER *timeout );
 239     NTSTATUS      (WINAPI *NtWaitForMultipleObjects)( DWORD count, const HANDLE *handles,
 240                                                       BOOLEAN wait_any, BOOLEAN alertable,
 241                                                       const LARGE_INTEGER *timeout );
 242     NTSTATUS      (WINAPI *NtWaitForSingleObject)( HANDLE handle, BOOLEAN alertable,
 243                                                    const LARGE_INTEGER *timeout );
 244     NTSTATUS      (WINAPI *NtWriteFile)( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
 245                                          IO_STATUS_BLOCK *io, const void *buffer, ULONG length,
 246                                          LARGE_INTEGER *offset, ULONG *key );
 247     NTSTATUS      (WINAPI *NtWriteFileGather)( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc,
 248                                                void *apc_user, IO_STATUS_BLOCK *io,
 249                                                FILE_SEGMENT_ELEMENT *segments, ULONG length,
 250                                                LARGE_INTEGER *offset, ULONG *key );
 251     NTSTATUS      (WINAPI *NtWriteVirtualMemory)( HANDLE process, void *addr, const void *buffer,
 252                                                   SIZE_T size, SIZE_T *bytes_written );
 253     NTSTATUS      (WINAPI *NtYieldExecution)(void);
 254
 255     /* other Win32 API functions */
 256     NTSTATUS      (WINAPI *DbgUiIssueRemoteBreakin)( HANDLE process );
 257     LONGLONG      (WINAPI *RtlGetSystemTimePrecise)(void);
 258     NTSTATUS      (WINAPI *RtlWaitOnAddress)( const void *addr, const void *cmp, SIZE_T size,
 259                                               const LARGE_INTEGER *timeout );
 260     void          (WINAPI *RtlWakeAddressAll)( const void *addr );
 261     void          (WINAPI *RtlWakeAddressSingle)( const void *addr );
 262
 263     /* fast locks */
 264     NTSTATUS      (CDECL *fast_RtlpWaitForCriticalSection)( RTL_CRITICAL_SECTION *crit, int timeout );
 265     NTSTATUS      (CDECL *fast_RtlpUnWaitCriticalSection)( RTL_CRITICAL_SECTION *crit );
 266     NTSTATUS      (CDECL *fast_RtlDeleteCriticalSection)( RTL_CRITICAL_SECTION *crit );
 267     NTSTATUS      (CDECL *fast_RtlTryAcquireSRWLockExclusive)( RTL_SRWLOCK *lock );
 268     NTSTATUS      (CDECL *fast_RtlAcquireSRWLockExclusive)( RTL_SRWLOCK *lock );
 269     NTSTATUS      (CDECL *fast_RtlTryAcquireSRWLockShared)( RTL_SRWLOCK *lock );
 270     NTSTATUS      (CDECL *fast_RtlAcquireSRWLockShared)( RTL_SRWLOCK *lock );
 271     NTSTATUS      (CDECL *fast_RtlReleaseSRWLockExclusive)( RTL_SRWLOCK *lock );
 272     NTSTATUS      (CDECL *fast_RtlReleaseSRWLockShared)( RTL_SRWLOCK *lock );
 273     NTSTATUS      (CDECL *fast_RtlSleepConditionVariableSRW)( RTL_CONDITION_VARIABLE *variable,
 274                                                               RTL_SRWLOCK *lock,
 275                                                               const LARGE_INTEGER *timeout, ULONG flags );
 276     NTSTATUS      (CDECL *fast_RtlSleepConditionVariableCS)( RTL_CONDITION_VARIABLE *variable,
 277                                                              RTL_CRITICAL_SECTION *cs,
 278                                                              const LARGE_INTEGER *timeout );
 279     NTSTATUS      (CDECL *fast_RtlWakeConditionVariable)( RTL_CONDITION_VARIABLE *variable, int count );
 280
 281     /* math functions */
 282     double        (CDECL *atan)( double d );
 283     double        (CDECL *ceil)( double d );
 284     double        (CDECL *cos)( double d );
 285     double        (CDECL *fabs)( double d );
 286     double        (CDECL *floor)( double d );
 287     double        (CDECL *log)( double d );
 288     double        (CDECL *pow)( double x, double y );
 289     double        (CDECL *sin)( double d );
 290     double        (CDECL *sqrt)( double d );
 291     double        (CDECL *tan)( double d );
 292
 293     /* environment functions */
 294     NTSTATUS      (CDECL *get_initial_environment)( WCHAR **wargv[], WCHAR *env, SIZE_T *size );
 295     NTSTATUS      (CDECL *get_startup_info)( startup_info_t *info, SIZE_T *total_size, SIZE_T *info_size );
 296     NTSTATUS      (CDECL *get_dynamic_environment)( WCHAR *env, SIZE_T *size );
 297     void          (CDECL *get_initial_console)( HANDLE *handle, HANDLE *std_in,
 298                                                 HANDLE *std_out, HANDLE *std_err );
 299     void          (CDECL *get_initial_directory)( UNICODE_STRING *dir );
 300     USHORT *      (CDECL *get_unix_codepage_data)(void);
 301     void          (CDECL *get_locales)( WCHAR *sys, WCHAR *user );
 302     const char *  (CDECL *get_version)(void);
 303     const char *  (CDECL *get_build_id)(void);
 304     void          (CDECL *get_host_version)( const char **sysname, const char **release );
 305
 306     /* virtual memory functions */
 307     NTSTATUS      (CDECL *virtual_map_section)( HANDLE handle, PVOID *addr_ptr, unsigned short zero_bits_64, SIZE_T commit_size,
 308                                                 const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr, ULONG alloc_type,
 309                                                 ULONG protect, pe_image_info_t *image_info );
 310     NTSTATUS      (CDECL *virtual_alloc_thread_stack)( INITIAL_TEB *stack, SIZE_T reserve_size, SIZE_T commit_size, SIZE_T *pthread_size );
 311     ssize_t       (CDECL *virtual_locked_recvmsg)( int fd, struct msghdr *hdr, int flags );
 312     void          (CDECL *virtual_release_address_space)(void);
 313     void          (CDECL *virtual_set_large_address_space)(void);
 314
 315     /* thread/process functions */
 316     void          (CDECL *exit_thread)( int status );
 317     void          (CDECL *exit_process)( int status );
 318     NTSTATUS      (CDECL *exec_process)( UNICODE_STRING *path, UNICODE_STRING *cmdline, NTSTATUS status );
 319
 320     /* server functions */
 321     unsigned int  (CDECL *server_call)( void *req_ptr );
 322     void          (CDECL *server_send_fd)( int fd );
 323     NTSTATUS      (CDECL *server_fd_to_handle)( int fd, unsigned int access, unsigned int attributes,
 324                                                 HANDLE *handle );
 325     NTSTATUS      (CDECL *server_handle_to_fd)( HANDLE handle, unsigned int access, int *unix_fd,
 326                                                 unsigned int *options );
 327     void          (CDECL *server_release_fd)( HANDLE handle, int unix_fd );
 328     void          (CDECL *server_init_process_done)( void *relay );
 329
 330     /* file functions */
 331     NTSTATUS      (CDECL *nt_to_unix_file_name)( const UNICODE_STRING *nameW, ANSI_STRING *unix_name_ret,
 332                                                  UINT disposition, BOOLEAN check_case );
 333     NTSTATUS      (CDECL *unix_to_nt_file_name)( const ANSI_STRING *name, UNICODE_STRING *nt );
 334     void          (CDECL *set_show_dot_files)( BOOL enable );
 335
 336     /* loader functions */
 337     NTSTATUS      (CDECL *load_so_dll)( UNICODE_STRING *nt_name, void **module );
 338     NTSTATUS      (CDECL *load_builtin_dll)( const WCHAR *name, void **module,
 339                                              pe_image_info_t *image_info );
 340     NTSTATUS      (CDECL *unload_builtin_dll)( void *module );
 341     void          (CDECL *init_builtin_dll)( void *module );
 342     NTSTATUS      (CDECL *unwind_builtin_dll)( ULONG type, struct _DISPATCHER_CONTEXT *dispatch,
 343                                                CONTEXT *context );
 344
 345     /* debugging functions */
 346     unsigned char (CDECL *dbg_get_channel_flags)( struct __wine_debug_channel *channel );
 347     const char *  (CDECL *dbg_strdup)( const char *str );
 348     int           (CDECL *dbg_output)( const char *str );
 349     int           (CDECL *dbg_header)( enum __wine_debug_class cls, struct __wine_debug_channel *channel,
 350                                        const char *function );
 351 };
 352
 353 #endif /* __NTDLL_UNIXLIB_H */