4 * This file contains the Nt* API functions of NTDLL.DLL.
5 * In the original ntdll.dll they all seem to just call int 0x2e (down to the NTOSKRNL)
7 * Copyright 1996-1998 Marcus Meissner
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
27 #ifdef HAVE_SYS_PARAM_H
28 # include <sys/param.h>
30 #ifdef HAVE_SYS_SYSCTL_H
31 # include <sys/sysctl.h>
33 #ifdef HAVE_MACHINE_CPU_H
34 # include <machine/cpu.h>
36 #ifdef HAVE_MACH_MACHINE_H
37 # include <mach/machine.h>
45 #ifdef HAVE_SYS_TIME_H
46 # include <sys/time.h>
50 #define NONAMELESSUNION
52 #define WIN32_NO_STATUS
53 #include "wine/debug.h"
54 #include "wine/unicode.h"
57 #include "ntdll_misc.h"
58 #include "wine/server.h"
62 #include <mach/mach_init.h>
63 #include <mach/mach_host.h>
64 #include <mach/vm_map.h>
67 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
73 /******************************************************************************
74 * NtDuplicateToken [NTDLL.@]
75 * ZwDuplicateToken [NTDLL.@]
77 NTSTATUS WINAPI
NtDuplicateToken(
78 IN HANDLE ExistingToken
,
79 IN ACCESS_MASK DesiredAccess
,
80 IN POBJECT_ATTRIBUTES ObjectAttributes
,
81 IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
,
82 IN TOKEN_TYPE TokenType
,
87 TRACE("(%p,0x%08x,%s,0x%08x,0x%08x,%p)\n",
88 ExistingToken
, DesiredAccess
, debugstr_ObjectAttributes(ObjectAttributes
),
89 ImpersonationLevel
, TokenType
, NewToken
);
91 if (ObjectAttributes
&& ObjectAttributes
->SecurityQualityOfService
)
93 SECURITY_QUALITY_OF_SERVICE
*SecurityQOS
= ObjectAttributes
->SecurityQualityOfService
;
94 TRACE("ObjectAttributes->SecurityQualityOfService = {%d, %d, %d, %s}\n",
95 SecurityQOS
->Length
, SecurityQOS
->ImpersonationLevel
,
96 SecurityQOS
->ContextTrackingMode
,
97 SecurityQOS
->EffectiveOnly
? "TRUE" : "FALSE");
98 ImpersonationLevel
= SecurityQOS
->ImpersonationLevel
;
101 SERVER_START_REQ( duplicate_token
)
103 req
->handle
= wine_server_obj_handle( ExistingToken
);
104 req
->access
= DesiredAccess
;
105 req
->attributes
= ObjectAttributes
? ObjectAttributes
->Attributes
: 0;
106 req
->primary
= (TokenType
== TokenPrimary
);
107 req
->impersonation_level
= ImpersonationLevel
;
108 status
= wine_server_call( req
);
109 if (!status
) *NewToken
= wine_server_ptr_handle( reply
->new_handle
);
116 /******************************************************************************
117 * NtOpenProcessToken [NTDLL.@]
118 * ZwOpenProcessToken [NTDLL.@]
120 NTSTATUS WINAPI
NtOpenProcessToken(
121 HANDLE ProcessHandle
,
125 return NtOpenProcessTokenEx( ProcessHandle
, DesiredAccess
, 0, TokenHandle
);
128 /******************************************************************************
129 * NtOpenProcessTokenEx [NTDLL.@]
130 * ZwOpenProcessTokenEx [NTDLL.@]
132 NTSTATUS WINAPI
NtOpenProcessTokenEx( HANDLE process
, DWORD access
, DWORD attributes
,
137 TRACE("(%p,0x%08x,0x%08x,%p)\n", process
, access
, attributes
, handle
);
139 SERVER_START_REQ( open_token
)
141 req
->handle
= wine_server_obj_handle( process
);
142 req
->access
= access
;
143 req
->attributes
= attributes
;
145 ret
= wine_server_call( req
);
146 if (!ret
) *handle
= wine_server_ptr_handle( reply
->token
);
152 /******************************************************************************
153 * NtOpenThreadToken [NTDLL.@]
154 * ZwOpenThreadToken [NTDLL.@]
156 NTSTATUS WINAPI
NtOpenThreadToken(
162 return NtOpenThreadTokenEx( ThreadHandle
, DesiredAccess
, OpenAsSelf
, 0, TokenHandle
);
165 /******************************************************************************
166 * NtOpenThreadTokenEx [NTDLL.@]
167 * ZwOpenThreadTokenEx [NTDLL.@]
169 NTSTATUS WINAPI
NtOpenThreadTokenEx( HANDLE thread
, DWORD access
, BOOLEAN as_self
, DWORD attributes
,
174 TRACE("(%p,0x%08x,%u,0x%08x,%p)\n", thread
, access
, as_self
, attributes
, handle
);
176 SERVER_START_REQ( open_token
)
178 req
->handle
= wine_server_obj_handle( thread
);
179 req
->access
= access
;
180 req
->attributes
= attributes
;
181 req
->flags
= OPEN_TOKEN_THREAD
;
182 if (as_self
) req
->flags
|= OPEN_TOKEN_AS_SELF
;
183 ret
= wine_server_call( req
);
184 if (!ret
) *handle
= wine_server_ptr_handle( reply
->token
);
191 /******************************************************************************
192 * NtAdjustPrivilegesToken [NTDLL.@]
193 * ZwAdjustPrivilegesToken [NTDLL.@]
195 * FIXME: parameters unsafe
197 NTSTATUS WINAPI
NtAdjustPrivilegesToken(
198 IN HANDLE TokenHandle
,
199 IN BOOLEAN DisableAllPrivileges
,
200 IN PTOKEN_PRIVILEGES NewState
,
201 IN DWORD BufferLength
,
202 OUT PTOKEN_PRIVILEGES PreviousState
,
203 OUT PDWORD ReturnLength
)
207 TRACE("(%p,0x%08x,%p,0x%08x,%p,%p)\n",
208 TokenHandle
, DisableAllPrivileges
, NewState
, BufferLength
, PreviousState
, ReturnLength
);
210 SERVER_START_REQ( adjust_token_privileges
)
212 req
->handle
= wine_server_obj_handle( TokenHandle
);
213 req
->disable_all
= DisableAllPrivileges
;
214 req
->get_modified_state
= (PreviousState
!= NULL
);
215 if (!DisableAllPrivileges
)
217 wine_server_add_data( req
, NewState
->Privileges
,
218 NewState
->PrivilegeCount
* sizeof(NewState
->Privileges
[0]) );
220 if (PreviousState
&& BufferLength
>= FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
))
221 wine_server_set_reply( req
, PreviousState
->Privileges
,
222 BufferLength
- FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) );
223 ret
= wine_server_call( req
);
226 if (ReturnLength
) *ReturnLength
= reply
->len
+ FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
);
227 PreviousState
->PrivilegeCount
= reply
->len
/ sizeof(LUID_AND_ATTRIBUTES
);
235 /******************************************************************************
236 * NtQueryInformationToken [NTDLL.@]
237 * ZwQueryInformationToken [NTDLL.@]
240 * Buffer for TokenUser:
241 * 0x00 TOKEN_USER the PSID field points to the SID
245 NTSTATUS WINAPI
NtQueryInformationToken(
247 TOKEN_INFORMATION_CLASS tokeninfoclass
,
249 ULONG tokeninfolength
,
252 static const ULONG info_len
[] =
257 0, /* TokenPrivileges */
259 0, /* TokenPrimaryGroup */
260 0, /* TokenDefaultDacl */
261 sizeof(TOKEN_SOURCE
), /* TokenSource */
262 sizeof(TOKEN_TYPE
), /* TokenType */
263 sizeof(SECURITY_IMPERSONATION_LEVEL
), /* TokenImpersonationLevel */
264 sizeof(TOKEN_STATISTICS
), /* TokenStatistics */
265 0, /* TokenRestrictedSids */
266 sizeof(DWORD
), /* TokenSessionId */
267 0, /* TokenGroupsAndPrivileges */
268 0, /* TokenSessionReference */
269 0, /* TokenSandBoxInert */
270 0, /* TokenAuditPolicy */
272 sizeof(TOKEN_ELEVATION_TYPE
), /* TokenElevationType */
273 0, /* TokenLinkedToken */
274 sizeof(TOKEN_ELEVATION
), /* TokenElevation */
275 0, /* TokenHasRestrictions */
276 0, /* TokenAccessInformation */
277 0, /* TokenVirtualizationAllowed */
278 0, /* TokenVirtualizationEnabled */
279 sizeof(TOKEN_MANDATORY_LABEL
) + sizeof(SID
), /* TokenIntegrityLevel [sizeof(SID) includes one SubAuthority] */
280 0, /* TokenUIAccess */
281 0, /* TokenMandatoryPolicy */
282 0, /* TokenLogonSid */
283 0, /* TokenIsAppContainer */
284 0, /* TokenCapabilities */
285 sizeof(TOKEN_APPCONTAINER_INFORMATION
) + sizeof(SID
), /* TokenAppContainerSid */
286 0, /* TokenAppContainerNumber */
287 0, /* TokenUserClaimAttributes*/
288 0, /* TokenDeviceClaimAttributes */
289 0, /* TokenRestrictedUserClaimAttributes */
290 0, /* TokenRestrictedDeviceClaimAttributes */
291 0, /* TokenDeviceGroups */
292 0, /* TokenRestrictedDeviceGroups */
293 0, /* TokenSecurityAttributes */
294 0, /* TokenIsRestricted */
295 0 /* TokenProcessTrustLevel */
299 NTSTATUS status
= STATUS_SUCCESS
;
301 TRACE("(%p,%d,%p,%d,%p)\n",
302 token
,tokeninfoclass
,tokeninfo
,tokeninfolength
,retlen
);
304 if (tokeninfoclass
< MaxTokenInfoClass
)
305 len
= info_len
[tokeninfoclass
];
307 if (retlen
) *retlen
= len
;
309 if (tokeninfolength
< len
)
310 return STATUS_BUFFER_TOO_SMALL
;
312 switch (tokeninfoclass
)
315 SERVER_START_REQ( get_token_sid
)
317 TOKEN_USER
* tuser
= tokeninfo
;
318 PSID sid
= tuser
+ 1;
319 DWORD sid_len
= tokeninfolength
< sizeof(TOKEN_USER
) ? 0 : tokeninfolength
- sizeof(TOKEN_USER
);
321 req
->handle
= wine_server_obj_handle( token
);
322 req
->which_sid
= tokeninfoclass
;
323 wine_server_set_reply( req
, sid
, sid_len
);
324 status
= wine_server_call( req
);
325 if (retlen
) *retlen
= reply
->sid_len
+ sizeof(TOKEN_USER
);
326 if (status
== STATUS_SUCCESS
)
328 tuser
->User
.Sid
= sid
;
329 tuser
->User
.Attributes
= 0;
338 /* reply buffer is always shorter than output one */
339 buffer
= tokeninfolength
? RtlAllocateHeap(GetProcessHeap(), 0, tokeninfolength
) : NULL
;
341 SERVER_START_REQ( get_token_groups
)
343 TOKEN_GROUPS
*groups
= tokeninfo
;
345 req
->handle
= wine_server_obj_handle( token
);
346 wine_server_set_reply( req
, buffer
, tokeninfolength
);
347 status
= wine_server_call( req
);
348 if (status
== STATUS_BUFFER_TOO_SMALL
)
350 if (retlen
) *retlen
= reply
->user_len
;
352 else if (status
== STATUS_SUCCESS
)
354 struct token_groups
*tg
= buffer
;
355 unsigned int *attr
= (unsigned int *)(tg
+ 1);
357 const int non_sid_portion
= (sizeof(struct token_groups
) + tg
->count
* sizeof(unsigned int));
358 SID
*sids
= (SID
*)((char *)tokeninfo
+ FIELD_OFFSET( TOKEN_GROUPS
, Groups
[tg
->count
] ));
360 if (retlen
) *retlen
= reply
->user_len
;
362 groups
->GroupCount
= tg
->count
;
363 memcpy( sids
, (char *)buffer
+ non_sid_portion
,
364 reply
->user_len
- FIELD_OFFSET( TOKEN_GROUPS
, Groups
[tg
->count
] ));
366 for (i
= 0; i
< tg
->count
; i
++)
368 groups
->Groups
[i
].Attributes
= attr
[i
];
369 groups
->Groups
[i
].Sid
= sids
;
370 sids
= (SID
*)((char *)sids
+ RtlLengthSid(sids
));
373 else if (retlen
) *retlen
= 0;
377 RtlFreeHeap(GetProcessHeap(), 0, buffer
);
380 case TokenPrimaryGroup
:
381 SERVER_START_REQ( get_token_sid
)
383 TOKEN_PRIMARY_GROUP
*tgroup
= tokeninfo
;
384 PSID sid
= tgroup
+ 1;
385 DWORD sid_len
= tokeninfolength
< sizeof(TOKEN_PRIMARY_GROUP
) ? 0 : tokeninfolength
- sizeof(TOKEN_PRIMARY_GROUP
);
387 req
->handle
= wine_server_obj_handle( token
);
388 req
->which_sid
= tokeninfoclass
;
389 wine_server_set_reply( req
, sid
, sid_len
);
390 status
= wine_server_call( req
);
391 if (retlen
) *retlen
= reply
->sid_len
+ sizeof(TOKEN_PRIMARY_GROUP
);
392 if (status
== STATUS_SUCCESS
)
393 tgroup
->PrimaryGroup
= sid
;
397 case TokenPrivileges
:
398 SERVER_START_REQ( get_token_privileges
)
400 TOKEN_PRIVILEGES
*tpriv
= tokeninfo
;
401 req
->handle
= wine_server_obj_handle( token
);
402 if (tpriv
&& tokeninfolength
> FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
))
403 wine_server_set_reply( req
, tpriv
->Privileges
, tokeninfolength
- FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) );
404 status
= wine_server_call( req
);
405 if (retlen
) *retlen
= FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) + reply
->len
;
406 if (tpriv
) tpriv
->PrivilegeCount
= reply
->len
/ sizeof(LUID_AND_ATTRIBUTES
);
411 SERVER_START_REQ( get_token_sid
)
413 TOKEN_OWNER
*towner
= tokeninfo
;
414 PSID sid
= towner
+ 1;
415 DWORD sid_len
= tokeninfolength
< sizeof(TOKEN_OWNER
) ? 0 : tokeninfolength
- sizeof(TOKEN_OWNER
);
417 req
->handle
= wine_server_obj_handle( token
);
418 req
->which_sid
= tokeninfoclass
;
419 wine_server_set_reply( req
, sid
, sid_len
);
420 status
= wine_server_call( req
);
421 if (retlen
) *retlen
= reply
->sid_len
+ sizeof(TOKEN_OWNER
);
422 if (status
== STATUS_SUCCESS
)
427 case TokenImpersonationLevel
:
428 SERVER_START_REQ( get_token_impersonation_level
)
430 SECURITY_IMPERSONATION_LEVEL
*impersonation_level
= tokeninfo
;
431 req
->handle
= wine_server_obj_handle( token
);
432 status
= wine_server_call( req
);
433 if (status
== STATUS_SUCCESS
)
434 *impersonation_level
= reply
->impersonation_level
;
438 case TokenStatistics
:
439 SERVER_START_REQ( get_token_statistics
)
441 TOKEN_STATISTICS
*statistics
= tokeninfo
;
442 req
->handle
= wine_server_obj_handle( token
);
443 status
= wine_server_call( req
);
444 if (status
== STATUS_SUCCESS
)
446 statistics
->TokenId
.LowPart
= reply
->token_id
.low_part
;
447 statistics
->TokenId
.HighPart
= reply
->token_id
.high_part
;
448 statistics
->AuthenticationId
.LowPart
= 0; /* FIXME */
449 statistics
->AuthenticationId
.HighPart
= 0; /* FIXME */
450 statistics
->ExpirationTime
.u
.HighPart
= 0x7fffffff;
451 statistics
->ExpirationTime
.u
.LowPart
= 0xffffffff;
452 statistics
->TokenType
= reply
->primary
? TokenPrimary
: TokenImpersonation
;
453 statistics
->ImpersonationLevel
= reply
->impersonation_level
;
455 /* kernel information not relevant to us */
456 statistics
->DynamicCharged
= 0;
457 statistics
->DynamicAvailable
= 0;
459 statistics
->GroupCount
= reply
->group_count
;
460 statistics
->PrivilegeCount
= reply
->privilege_count
;
461 statistics
->ModifiedId
.LowPart
= reply
->modified_id
.low_part
;
462 statistics
->ModifiedId
.HighPart
= reply
->modified_id
.high_part
;
468 SERVER_START_REQ( get_token_statistics
)
470 TOKEN_TYPE
*token_type
= tokeninfo
;
471 req
->handle
= wine_server_obj_handle( token
);
472 status
= wine_server_call( req
);
473 if (status
== STATUS_SUCCESS
)
474 *token_type
= reply
->primary
? TokenPrimary
: TokenImpersonation
;
478 case TokenDefaultDacl
:
479 SERVER_START_REQ( get_token_default_dacl
)
481 TOKEN_DEFAULT_DACL
*default_dacl
= tokeninfo
;
482 ACL
*acl
= (ACL
*)(default_dacl
+ 1);
485 if (tokeninfolength
< sizeof(TOKEN_DEFAULT_DACL
)) acl_len
= 0;
486 else acl_len
= tokeninfolength
- sizeof(TOKEN_DEFAULT_DACL
);
488 req
->handle
= wine_server_obj_handle( token
);
489 wine_server_set_reply( req
, acl
, acl_len
);
490 status
= wine_server_call( req
);
492 if (retlen
) *retlen
= reply
->acl_len
+ sizeof(TOKEN_DEFAULT_DACL
);
493 if (status
== STATUS_SUCCESS
)
496 default_dacl
->DefaultDacl
= acl
;
498 default_dacl
->DefaultDacl
= NULL
;
503 case TokenElevationType
:
505 TOKEN_ELEVATION_TYPE
*elevation_type
= tokeninfo
;
506 FIXME("QueryInformationToken( ..., TokenElevationType, ...) semi-stub\n");
507 *elevation_type
= TokenElevationTypeFull
;
512 TOKEN_ELEVATION
*elevation
= tokeninfo
;
513 FIXME("QueryInformationToken( ..., TokenElevation, ...) semi-stub\n");
514 elevation
->TokenIsElevated
= TRUE
;
519 *((DWORD
*)tokeninfo
) = 0;
520 FIXME("QueryInformationToken( ..., TokenSessionId, ...) semi-stub\n");
523 case TokenIntegrityLevel
:
525 /* report always "S-1-16-12288" (high mandatory level) for now */
526 static const SID high_level
= {SID_REVISION
, 1, {SECURITY_MANDATORY_LABEL_AUTHORITY
},
527 {SECURITY_MANDATORY_HIGH_RID
}};
529 TOKEN_MANDATORY_LABEL
*tml
= tokeninfo
;
532 tml
->Label
.Sid
= psid
;
533 tml
->Label
.Attributes
= SE_GROUP_INTEGRITY
| SE_GROUP_INTEGRITY_ENABLED
;
534 memcpy(psid
, &high_level
, sizeof(SID
));
537 case TokenAppContainerSid
:
539 TOKEN_APPCONTAINER_INFORMATION
*container
= tokeninfo
;
540 FIXME("QueryInformationToken( ..., TokenAppContainerSid, ...) semi-stub\n");
541 container
->TokenAppContainer
= NULL
;
546 ERR("Unhandled Token Information class %d!\n", tokeninfoclass
);
547 return STATUS_NOT_IMPLEMENTED
;
553 /******************************************************************************
554 * NtSetInformationToken [NTDLL.@]
555 * ZwSetInformationToken [NTDLL.@]
557 NTSTATUS WINAPI
NtSetInformationToken(
559 TOKEN_INFORMATION_CLASS TokenInformationClass
,
560 PVOID TokenInformation
,
561 ULONG TokenInformationLength
)
563 NTSTATUS ret
= STATUS_NOT_IMPLEMENTED
;
565 TRACE("%p %d %p %u\n", TokenHandle
, TokenInformationClass
,
566 TokenInformation
, TokenInformationLength
);
568 switch (TokenInformationClass
)
570 case TokenDefaultDacl
:
571 if (TokenInformationLength
< sizeof(TOKEN_DEFAULT_DACL
))
573 ret
= STATUS_INFO_LENGTH_MISMATCH
;
576 if (!TokenInformation
)
578 ret
= STATUS_ACCESS_VIOLATION
;
581 SERVER_START_REQ( set_token_default_dacl
)
583 ACL
*acl
= ((TOKEN_DEFAULT_DACL
*)TokenInformation
)->DefaultDacl
;
586 if (acl
) size
= acl
->AclSize
;
589 req
->handle
= wine_server_obj_handle( TokenHandle
);
590 wine_server_add_data( req
, acl
, size
);
591 ret
= wine_server_call( req
);
596 FIXME("unimplemented class %u\n", TokenInformationClass
);
603 /******************************************************************************
604 * NtAdjustGroupsToken [NTDLL.@]
605 * ZwAdjustGroupsToken [NTDLL.@]
607 NTSTATUS WINAPI
NtAdjustGroupsToken(
609 BOOLEAN ResetToDefault
,
610 PTOKEN_GROUPS NewState
,
612 PTOKEN_GROUPS PreviousState
,
615 FIXME("%p %d %p %u %p %p\n", TokenHandle
, ResetToDefault
,
616 NewState
, BufferLength
, PreviousState
, ReturnLength
);
617 return STATUS_NOT_IMPLEMENTED
;
620 /******************************************************************************
621 * NtPrivilegeCheck [NTDLL.@]
622 * ZwPrivilegeCheck [NTDLL.@]
624 NTSTATUS WINAPI
NtPrivilegeCheck(
626 PPRIVILEGE_SET RequiredPrivileges
,
630 SERVER_START_REQ( check_token_privileges
)
632 req
->handle
= wine_server_obj_handle( ClientToken
);
633 req
->all_required
= (RequiredPrivileges
->Control
& PRIVILEGE_SET_ALL_NECESSARY
) != 0;
634 wine_server_add_data( req
, RequiredPrivileges
->Privilege
,
635 RequiredPrivileges
->PrivilegeCount
* sizeof(RequiredPrivileges
->Privilege
[0]) );
636 wine_server_set_reply( req
, RequiredPrivileges
->Privilege
,
637 RequiredPrivileges
->PrivilegeCount
* sizeof(RequiredPrivileges
->Privilege
[0]) );
639 status
= wine_server_call( req
);
641 if (status
== STATUS_SUCCESS
)
642 *Result
= reply
->has_privileges
!= 0;
652 /******************************************************************************
653 * NtQuerySection [NTDLL.@]
655 NTSTATUS WINAPI
NtQuerySection(
656 IN HANDLE SectionHandle
,
657 IN SECTION_INFORMATION_CLASS SectionInformationClass
,
658 OUT PVOID SectionInformation
,
660 OUT PULONG ResultLength
)
662 FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
663 SectionHandle
,SectionInformationClass
,SectionInformation
,Length
,ResultLength
);
671 /******************************************************************************
672 * NtCreatePort [NTDLL.@]
673 * ZwCreatePort [NTDLL.@]
675 NTSTATUS WINAPI
NtCreatePort(PHANDLE PortHandle
,POBJECT_ATTRIBUTES ObjectAttributes
,
676 ULONG MaxConnectInfoLength
,ULONG MaxDataLength
,PULONG reserved
)
678 FIXME("(%p,%p,%u,%u,%p),stub!\n",PortHandle
,ObjectAttributes
,
679 MaxConnectInfoLength
,MaxDataLength
,reserved
);
680 return STATUS_NOT_IMPLEMENTED
;
683 /******************************************************************************
684 * NtConnectPort [NTDLL.@]
685 * ZwConnectPort [NTDLL.@]
687 NTSTATUS WINAPI
NtConnectPort(
689 PUNICODE_STRING PortName
,
690 PSECURITY_QUALITY_OF_SERVICE SecurityQos
,
691 PLPC_SECTION_WRITE WriteSection
,
692 PLPC_SECTION_READ ReadSection
,
693 PULONG MaximumMessageLength
,
695 PULONG pConnectInfoLength
)
697 FIXME("(%p,%s,%p,%p,%p,%p,%p,%p),stub!\n",
698 PortHandle
,debugstr_w(PortName
->Buffer
),SecurityQos
,
699 WriteSection
,ReadSection
,MaximumMessageLength
,ConnectInfo
,
701 if (ConnectInfo
&& pConnectInfoLength
)
702 TRACE("\tMessage = %s\n",debugstr_an(ConnectInfo
,*pConnectInfoLength
));
703 return STATUS_NOT_IMPLEMENTED
;
706 /******************************************************************************
707 * NtSecureConnectPort (NTDLL.@)
708 * ZwSecureConnectPort (NTDLL.@)
710 NTSTATUS WINAPI
NtSecureConnectPort(
712 PUNICODE_STRING PortName
,
713 PSECURITY_QUALITY_OF_SERVICE SecurityQos
,
714 PLPC_SECTION_WRITE WriteSection
,
716 PLPC_SECTION_READ ReadSection
,
717 PULONG MaximumMessageLength
,
719 PULONG pConnectInfoLength
)
721 FIXME("(%p,%s,%p,%p,%p,%p,%p,%p,%p),stub!\n",
722 PortHandle
,debugstr_w(PortName
->Buffer
),SecurityQos
,
723 WriteSection
,pSid
,ReadSection
,MaximumMessageLength
,ConnectInfo
,
725 return STATUS_NOT_IMPLEMENTED
;
728 /******************************************************************************
729 * NtListenPort [NTDLL.@]
730 * ZwListenPort [NTDLL.@]
732 NTSTATUS WINAPI
NtListenPort(HANDLE PortHandle
,PLPC_MESSAGE pLpcMessage
)
734 FIXME("(%p,%p),stub!\n",PortHandle
,pLpcMessage
);
735 return STATUS_NOT_IMPLEMENTED
;
738 /******************************************************************************
739 * NtAcceptConnectPort [NTDLL.@]
740 * ZwAcceptConnectPort [NTDLL.@]
742 NTSTATUS WINAPI
NtAcceptConnectPort(
744 ULONG PortIdentifier
,
745 PLPC_MESSAGE pLpcMessage
,
747 PLPC_SECTION_WRITE WriteSection
,
748 PLPC_SECTION_READ ReadSection
)
750 FIXME("(%p,%u,%p,%d,%p,%p),stub!\n",
751 PortHandle
,PortIdentifier
,pLpcMessage
,Accept
,WriteSection
,ReadSection
);
752 return STATUS_NOT_IMPLEMENTED
;
755 /******************************************************************************
756 * NtCompleteConnectPort [NTDLL.@]
757 * ZwCompleteConnectPort [NTDLL.@]
759 NTSTATUS WINAPI
NtCompleteConnectPort(HANDLE PortHandle
)
761 FIXME("(%p),stub!\n",PortHandle
);
762 return STATUS_NOT_IMPLEMENTED
;
765 /******************************************************************************
766 * NtRegisterThreadTerminatePort [NTDLL.@]
767 * ZwRegisterThreadTerminatePort [NTDLL.@]
769 NTSTATUS WINAPI
NtRegisterThreadTerminatePort(HANDLE PortHandle
)
771 FIXME("(%p),stub!\n",PortHandle
);
772 return STATUS_NOT_IMPLEMENTED
;
775 /******************************************************************************
776 * NtRequestWaitReplyPort [NTDLL.@]
777 * ZwRequestWaitReplyPort [NTDLL.@]
779 NTSTATUS WINAPI
NtRequestWaitReplyPort(
781 PLPC_MESSAGE pLpcMessageIn
,
782 PLPC_MESSAGE pLpcMessageOut
)
784 FIXME("(%p,%p,%p),stub!\n",PortHandle
,pLpcMessageIn
,pLpcMessageOut
);
787 TRACE("Message to send:\n");
788 TRACE("\tDataSize = %u\n",pLpcMessageIn
->DataSize
);
789 TRACE("\tMessageSize = %u\n",pLpcMessageIn
->MessageSize
);
790 TRACE("\tMessageType = %u\n",pLpcMessageIn
->MessageType
);
791 TRACE("\tVirtualRangesOffset = %u\n",pLpcMessageIn
->VirtualRangesOffset
);
792 TRACE("\tClientId.UniqueProcess = %p\n",pLpcMessageIn
->ClientId
.UniqueProcess
);
793 TRACE("\tClientId.UniqueThread = %p\n",pLpcMessageIn
->ClientId
.UniqueThread
);
794 TRACE("\tMessageId = %lu\n",pLpcMessageIn
->MessageId
);
795 TRACE("\tSectionSize = %lu\n",pLpcMessageIn
->SectionSize
);
796 TRACE("\tData = %s\n",
797 debugstr_an((const char*)pLpcMessageIn
->Data
,pLpcMessageIn
->DataSize
));
799 return STATUS_NOT_IMPLEMENTED
;
802 /******************************************************************************
803 * NtReplyWaitReceivePort [NTDLL.@]
804 * ZwReplyWaitReceivePort [NTDLL.@]
806 NTSTATUS WINAPI
NtReplyWaitReceivePort(
808 PULONG PortIdentifier
,
809 PLPC_MESSAGE ReplyMessage
,
810 PLPC_MESSAGE Message
)
812 FIXME("(%p,%p,%p,%p),stub!\n",PortHandle
,PortIdentifier
,ReplyMessage
,Message
);
813 return STATUS_NOT_IMPLEMENTED
;
820 /******************************************************************************
821 * NtSetIntervalProfile [NTDLL.@]
822 * ZwSetIntervalProfile [NTDLL.@]
824 NTSTATUS WINAPI
NtSetIntervalProfile(
826 KPROFILE_SOURCE Source
)
828 FIXME("%u,%d\n", Interval
, Source
);
829 return STATUS_SUCCESS
;
832 static SYSTEM_CPU_INFORMATION cached_sci
;
834 /*******************************************************************************
835 * Architecture specific feature detection for CPUs
837 * This a set of mutually exclusive #if define()s each providing its own get_cpuinfo() to be called
838 * from fill_cpu_info();
840 #if defined(__i386__) || defined(__x86_64__)
842 #define AUTH 0x68747541 /* "Auth" */
843 #define ENTI 0x69746e65 /* "enti" */
844 #define CAMD 0x444d4163 /* "cAMD" */
846 #define GENU 0x756e6547 /* "Genu" */
847 #define INEI 0x49656e69 /* "ineI" */
848 #define NTEL 0x6c65746e /* "ntel" */
850 /* Calls cpuid with an eax of 'ax' and returns the 16 bytes in *p
851 * We are compiled with -fPIC, so we can't clobber ebx.
853 static inline void do_cpuid(unsigned int ax
, unsigned int *p
)
856 __asm__("pushl %%ebx\n\t"
858 "movl %%ebx, %%esi\n\t"
860 : "=a" (p
[0]), "=S" (p
[1]), "=c" (p
[2]), "=d" (p
[3])
862 #elif defined(__x86_64__)
863 __asm__("push %%rbx\n\t"
865 "movq %%rbx, %%rsi\n\t"
867 : "=a" (p
[0]), "=S" (p
[1]), "=c" (p
[2]), "=d" (p
[3])
872 /* From xf86info havecpuid.c 1.11 */
873 static inline BOOL
have_cpuid(void)
887 : "=&r" (f1
), "=&r" (f2
)
888 : "ir" (0x00200000));
889 return ((f1
^f2
) & 0x00200000) != 0;
890 #elif defined(__x86_64__)
897 /* Detect if a SSE2 processor is capable of Denormals Are Zero (DAZ) mode.
899 * This function assumes you have already checked for SSE2/FXSAVE support. */
900 static inline BOOL
have_sse_daz_mode(void)
903 typedef struct DECLSPEC_ALIGN(16) _M128A
{
908 typedef struct _XMM_SAVE_AREA32
{
922 M128A FloatRegisters
[8];
923 M128A XmmRegisters
[16];
927 /* Intel says we need a zeroed 16-byte aligned buffer */
928 char buffer
[512 + 16];
929 XMM_SAVE_AREA32
*state
= (XMM_SAVE_AREA32
*)(((ULONG_PTR
)buffer
+ 15) & ~15);
930 memset(buffer
, 0, sizeof(buffer
));
932 __asm__
__volatile__( "fxsave %0" : "=m" (*state
) : "m" (*state
) );
934 return (state
->MxCsr_Mask
& (1 << 6)) >> 6;
935 #else /* all x86_64 processors include SSE2 with DAZ mode */
940 static inline void get_cpuinfo(SYSTEM_CPU_INFORMATION
* info
)
942 unsigned int regs
[4], regs2
[4];
944 #if defined(__i386__)
945 info
->Architecture
= PROCESSOR_ARCHITECTURE_INTEL
;
946 #elif defined(__x86_64__)
947 info
->Architecture
= PROCESSOR_ARCHITECTURE_AMD64
;
950 /* We're at least a 386 */
951 info
->FeatureSet
= CPU_FEATURE_VME
| CPU_FEATURE_X86
| CPU_FEATURE_PGE
;
954 if (!have_cpuid()) return;
956 do_cpuid(0x00000000, regs
); /* get standard cpuid level and vendor name */
957 if (regs
[0]>=0x00000001) /* Check for supported cpuid version */
959 do_cpuid(0x00000001, regs2
); /* get cpu features */
961 if(regs2
[3] & (1 << 3 )) info
->FeatureSet
|= CPU_FEATURE_PSE
;
962 if(regs2
[3] & (1 << 4 )) info
->FeatureSet
|= CPU_FEATURE_TSC
;
963 if(regs2
[3] & (1 << 8 )) info
->FeatureSet
|= CPU_FEATURE_CX8
;
964 if(regs2
[3] & (1 << 11)) info
->FeatureSet
|= CPU_FEATURE_SEP
;
965 if(regs2
[3] & (1 << 12)) info
->FeatureSet
|= CPU_FEATURE_MTRR
;
966 if(regs2
[3] & (1 << 15)) info
->FeatureSet
|= CPU_FEATURE_CMOV
;
967 if(regs2
[3] & (1 << 16)) info
->FeatureSet
|= CPU_FEATURE_PAT
;
968 if(regs2
[3] & (1 << 23)) info
->FeatureSet
|= CPU_FEATURE_MMX
;
969 if(regs2
[3] & (1 << 24)) info
->FeatureSet
|= CPU_FEATURE_FXSR
;
970 if(regs2
[3] & (1 << 25)) info
->FeatureSet
|= CPU_FEATURE_SSE
;
971 if(regs2
[3] & (1 << 26)) info
->FeatureSet
|= CPU_FEATURE_SSE2
;
973 user_shared_data
->ProcessorFeatures
[PF_FLOATING_POINT_EMULATED
] = !(regs2
[3] & 1);
974 user_shared_data
->ProcessorFeatures
[PF_RDTSC_INSTRUCTION_AVAILABLE
] = (regs2
[3] & (1 << 4 )) >> 4;
975 user_shared_data
->ProcessorFeatures
[PF_PAE_ENABLED
] = (regs2
[3] & (1 << 6 )) >> 6;
976 user_shared_data
->ProcessorFeatures
[PF_COMPARE_EXCHANGE_DOUBLE
] = (regs2
[3] & (1 << 8 )) >> 8;
977 user_shared_data
->ProcessorFeatures
[PF_MMX_INSTRUCTIONS_AVAILABLE
] = (regs2
[3] & (1 << 23)) >> 23;
978 user_shared_data
->ProcessorFeatures
[PF_XMMI_INSTRUCTIONS_AVAILABLE
] = (regs2
[3] & (1 << 25)) >> 25;
979 user_shared_data
->ProcessorFeatures
[PF_XMMI64_INSTRUCTIONS_AVAILABLE
] = (regs2
[3] & (1 << 26)) >> 26;
980 user_shared_data
->ProcessorFeatures
[PF_SSE3_INSTRUCTIONS_AVAILABLE
] = regs2
[2] & 1;
981 user_shared_data
->ProcessorFeatures
[PF_XSAVE_ENABLED
] = (regs2
[2] & (1 << 27)) >> 27;
982 user_shared_data
->ProcessorFeatures
[PF_COMPARE_EXCHANGE128
] = (regs2
[2] & (1 << 13)) >> 13;
984 if((regs2
[3] & (1 << 26)) && (regs2
[3] & (1 << 24))) /* has SSE2 and FXSAVE/FXRSTOR */
985 user_shared_data
->ProcessorFeatures
[PF_SSE_DAZ_MODE_AVAILABLE
] = have_sse_daz_mode();
987 if (regs
[1] == AUTH
&& regs
[3] == ENTI
&& regs
[2] == CAMD
)
989 info
->Level
= (regs2
[0] >> 8) & 0xf; /* family */
990 if (info
->Level
== 0xf) /* AMD says to add the extended family to the family if family is 0xf */
991 info
->Level
+= (regs2
[0] >> 20) & 0xff;
993 /* repack model and stepping to make a "revision" */
994 info
->Revision
= ((regs2
[0] >> 16) & 0xf) << 12; /* extended model */
995 info
->Revision
|= ((regs2
[0] >> 4 ) & 0xf) << 8; /* model */
996 info
->Revision
|= regs2
[0] & 0xf; /* stepping */
998 do_cpuid(0x80000000, regs
); /* get vendor cpuid level */
999 if (regs
[0] >= 0x80000001)
1001 do_cpuid(0x80000001, regs2
); /* get vendor features */
1002 user_shared_data
->ProcessorFeatures
[PF_VIRT_FIRMWARE_ENABLED
] = (regs2
[2] & (1 << 2 )) >> 2;
1003 user_shared_data
->ProcessorFeatures
[PF_NX_ENABLED
] = (regs2
[3] & (1 << 20 )) >> 20;
1004 user_shared_data
->ProcessorFeatures
[PF_3DNOW_INSTRUCTIONS_AVAILABLE
] = (regs2
[3] & (1 << 31 )) >> 31;
1005 if(regs2
[3] & (1 << 31)) info
->FeatureSet
|= CPU_FEATURE_3DNOW
;
1008 else if (regs
[1] == GENU
&& regs
[3] == INEI
&& regs
[2] == NTEL
)
1010 info
->Level
= ((regs2
[0] >> 8) & 0xf) + ((regs2
[0] >> 20) & 0xff); /* family + extended family */
1011 if(info
->Level
== 15) info
->Level
= 6;
1013 /* repack model and stepping to make a "revision" */
1014 info
->Revision
= ((regs2
[0] >> 16) & 0xf) << 12; /* extended model */
1015 info
->Revision
|= ((regs2
[0] >> 4 ) & 0xf) << 8; /* model */
1016 info
->Revision
|= regs2
[0] & 0xf; /* stepping */
1018 if(regs2
[3] & (1 << 21)) info
->FeatureSet
|= CPU_FEATURE_DS
;
1019 user_shared_data
->ProcessorFeatures
[PF_VIRT_FIRMWARE_ENABLED
] = (regs2
[2] & (1 << 5 )) >> 5;
1021 do_cpuid(0x80000000, regs
); /* get vendor cpuid level */
1022 if (regs
[0] >= 0x80000001)
1024 do_cpuid(0x80000001, regs2
); /* get vendor features */
1025 user_shared_data
->ProcessorFeatures
[PF_NX_ENABLED
] = (regs2
[3] & (1 << 20 )) >> 20;
1030 info
->Level
= (regs2
[0] >> 8) & 0xf; /* family */
1032 /* repack model and stepping to make a "revision" */
1033 info
->Revision
= ((regs2
[0] >> 4 ) & 0xf) << 8; /* model */
1034 info
->Revision
|= regs2
[0] & 0xf; /* stepping */
1039 #elif defined(__powerpc__) || defined(__ppc__)
1041 static inline void get_cpuinfo(SYSTEM_CPU_INFORMATION
* info
)
1047 valSize
= sizeof(value
);
1048 if (sysctlbyname("hw.optional.floatingpoint", &value
, &valSize
, NULL
, 0) == 0)
1049 user_shared_data
->ProcessorFeatures
[PF_FLOATING_POINT_EMULATED
] = !value
;
1051 valSize
= sizeof(value
);
1052 if (sysctlbyname("hw.cpusubtype", &value
, &valSize
, NULL
, 0) == 0)
1056 case CPU_SUBTYPE_POWERPC_601
:
1057 case CPU_SUBTYPE_POWERPC_602
: info
->Level
= 1; break;
1058 case CPU_SUBTYPE_POWERPC_603
: info
->Level
= 3; break;
1059 case CPU_SUBTYPE_POWERPC_603e
:
1060 case CPU_SUBTYPE_POWERPC_603ev
: info
->Level
= 6; break;
1061 case CPU_SUBTYPE_POWERPC_604
: info
->Level
= 4; break;
1062 case CPU_SUBTYPE_POWERPC_604e
: info
->Level
= 9; break;
1063 case CPU_SUBTYPE_POWERPC_620
: info
->Level
= 20; break;
1064 case CPU_SUBTYPE_POWERPC_750
: /* G3/G4 derive from 603 so ... */
1065 case CPU_SUBTYPE_POWERPC_7400
:
1066 case CPU_SUBTYPE_POWERPC_7450
: info
->Level
= 6; break;
1067 case CPU_SUBTYPE_POWERPC_970
: info
->Level
= 9;
1068 /* :o) user_shared_data->ProcessorFeatures[PF_ALTIVEC_INSTRUCTIONS_AVAILABLE] ;-) */
1074 FIXME("CPU Feature detection not implemented.\n");
1076 info
->Architecture
= PROCESSOR_ARCHITECTURE_PPC
;
1079 #elif defined(__arm__)
1081 static inline void get_cpuinfo(SYSTEM_CPU_INFORMATION
* info
)
1086 FILE *f
= fopen("/proc/cpuinfo", "r");
1089 while (fgets(line
, sizeof(line
), f
) != NULL
)
1091 /* NOTE: the ':' is the only character we can rely on */
1092 if (!(value
= strchr(line
,':')))
1094 /* terminate the valuename */
1096 while ((s
>= line
) && isspace(*s
)) s
--;
1098 /* and strip leading spaces from value */
1100 while (isspace(*value
)) value
++;
1101 if ((s
= strchr(value
,'\n')))
1103 if (!strcasecmp(line
, "CPU architecture"))
1105 if (isdigit(value
[0]))
1106 info
->Level
= atoi(value
);
1109 if (!strcasecmp(line
, "CPU revision"))
1111 if (isdigit(value
[0]))
1112 info
->Revision
= atoi(value
);
1115 if (!strcasecmp(line
, "features"))
1117 if (strstr(value
, "vfpv3"))
1118 user_shared_data
->ProcessorFeatures
[PF_ARM_VFP_32_REGISTERS_AVAILABLE
] = TRUE
;
1119 if (strstr(value
, "neon"))
1120 user_shared_data
->ProcessorFeatures
[PF_ARM_NEON_INSTRUCTIONS_AVAILABLE
] = TRUE
;
1126 #elif defined(__FreeBSD__)
1131 valsize
= sizeof(buf
);
1132 if (!sysctlbyname("hw.machine_arch", &buf
, &valsize
, NULL
, 0) &&
1133 sscanf(buf
, "armv%i", &value
) == 1)
1134 info
->Level
= value
;
1136 valsize
= sizeof(value
);
1137 if (!sysctlbyname("hw.floatingpoint", &value
, &valsize
, NULL
, 0))
1138 user_shared_data
->ProcessorFeatures
[PF_ARM_VFP_32_REGISTERS_AVAILABLE
] = value
;
1140 FIXME("CPU Feature detection not implemented.\n");
1142 info
->Architecture
= PROCESSOR_ARCHITECTURE_ARM
;
1145 #elif defined(__aarch64__)
1147 static inline void get_cpuinfo(SYSTEM_CPU_INFORMATION
* info
)
1150 info
->Architecture
= PROCESSOR_ARCHITECTURE_ARM
;
1153 #endif /* End architecture specific feature detection for CPUs */
1155 /******************************************************************
1158 * inits a couple of places with CPU related information:
1159 * - cached_sci in this file
1160 * - Peb->NumberOfProcessors
1161 * - SharedUserData->ProcessFeatures[] array
1163 void fill_cpu_info(void)
1167 #ifdef _SC_NPROCESSORS_ONLN
1168 num
= sysconf(_SC_NPROCESSORS_ONLN
);
1172 WARN("Failed to detect the number of processors.\n");
1174 #elif defined(CTL_HW) && defined(HW_NCPU)
1176 size_t len
= sizeof(num
);
1179 if (sysctl(mib
, 2, &num
, &len
, NULL
, 0) != 0)
1182 WARN("Failed to detect the number of processors.\n");
1186 FIXME("Detecting the number of processors is not supported.\n");
1188 NtCurrentTeb()->Peb
->NumberOfProcessors
= num
;
1190 memset(&cached_sci
, 0, sizeof(cached_sci
));
1191 get_cpuinfo(&cached_sci
);
1193 TRACE("<- CPU arch %d, level %d, rev %d, features 0x%x\n",
1194 cached_sci
.Architecture
, cached_sci
.Level
, cached_sci
.Revision
, cached_sci
.FeatureSet
);
1198 static inline BOOL
logical_proc_info_add_by_id(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*data
,
1199 DWORD
*len
, DWORD max_len
, LOGICAL_PROCESSOR_RELATIONSHIP rel
, DWORD id
, DWORD proc
)
1203 for(i
=0; i
<*len
; i
++)
1205 if(data
[i
].Relationship
!=rel
|| data
[i
].u
.Reserved
[1]!=id
)
1208 data
[i
].ProcessorMask
|= (ULONG_PTR
)1<<proc
;
1215 data
[i
].Relationship
= rel
;
1216 data
[i
].ProcessorMask
= (ULONG_PTR
)1<<proc
;
1217 /* TODO: set processor core flags */
1218 data
[i
].u
.Reserved
[0] = 0;
1219 data
[i
].u
.Reserved
[1] = id
;
1224 static inline BOOL
logical_proc_info_add_cache(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*data
,
1225 DWORD
*len
, DWORD max_len
, ULONG_PTR mask
, CACHE_DESCRIPTOR
*cache
)
1229 for(i
=0; i
<*len
; i
++)
1231 if(data
[i
].Relationship
==RelationCache
&& data
[i
].ProcessorMask
==mask
1232 && data
[i
].u
.Cache
.Level
==cache
->Level
&& data
[i
].u
.Cache
.Type
==cache
->Type
)
1239 data
[i
].Relationship
= RelationCache
;
1240 data
[i
].ProcessorMask
= mask
;
1241 data
[i
].u
.Cache
= *cache
;
1246 static inline BOOL
logical_proc_info_add_numa_node(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*data
,
1247 DWORD
*len
, DWORD max_len
, ULONG_PTR mask
, DWORD node_id
)
1252 data
[*len
].Relationship
= RelationNumaNode
;
1253 data
[*len
].ProcessorMask
= mask
;
1254 data
[*len
].u
.NumaNode
.NodeNumber
= node_id
;
1259 static NTSTATUS
create_logical_proc_info(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
**data
, DWORD
*max_len
)
1261 static const char core_info
[] = "/sys/devices/system/cpu/cpu%d/%s";
1262 static const char cache_info
[] = "/sys/devices/system/cpu/cpu%d/cache/index%d/%s";
1263 static const char numa_info
[] = "/sys/devices/system/node/node%d/cpumap";
1265 FILE *fcpu_list
, *fnuma_list
, *f
;
1266 DWORD len
= 0, beg
, end
, i
, j
, r
;
1267 char op
, name
[MAX_PATH
];
1269 fcpu_list
= fopen("/sys/devices/system/cpu/online", "r");
1271 return STATUS_NOT_IMPLEMENTED
;
1273 while(!feof(fcpu_list
))
1275 if(!fscanf(fcpu_list
, "%u%c ", &beg
, &op
))
1277 if(op
== '-') fscanf(fcpu_list
, "%u%c ", &end
, &op
);
1280 for(i
=beg
; i
<=end
; i
++)
1282 if(i
> 8*sizeof(ULONG_PTR
))
1284 FIXME("skipping logical processor %d\n", i
);
1288 sprintf(name
, core_info
, i
, "core_id");
1289 f
= fopen(name
, "r");
1292 fscanf(f
, "%u", &r
);
1296 if(!logical_proc_info_add_by_id(*data
, &len
, *max_len
, RelationProcessorCore
, r
, i
))
1298 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*new_data
;
1301 new_data
= RtlReAllocateHeap(GetProcessHeap(), 0, *data
, *max_len
*sizeof(*new_data
));
1305 return STATUS_NO_MEMORY
;
1309 logical_proc_info_add_by_id(*data
, &len
, *max_len
, RelationProcessorCore
, r
, i
);
1312 sprintf(name
, core_info
, i
, "physical_package_id");
1313 f
= fopen(name
, "r");
1316 fscanf(f
, "%u", &r
);
1320 if(!logical_proc_info_add_by_id(*data
, &len
, *max_len
, RelationProcessorPackage
, r
, i
))
1322 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*new_data
;
1325 new_data
= RtlReAllocateHeap(GetProcessHeap(), 0, *data
, *max_len
*sizeof(*new_data
));
1329 return STATUS_NO_MEMORY
;
1333 logical_proc_info_add_by_id(*data
, &len
, *max_len
, RelationProcessorPackage
, r
, i
);
1338 CACHE_DESCRIPTOR cache
;
1341 sprintf(name
, cache_info
, i
, j
, "shared_cpu_map");
1342 f
= fopen(name
, "r");
1346 if(!fscanf(f
, "%x%c ", &r
, &op
))
1348 mask
= (sizeof(ULONG_PTR
)>sizeof(int) ? mask
<<(8*sizeof(DWORD
)) : 0) + r
;
1352 sprintf(name
, cache_info
, i
, j
, "level");
1353 f
= fopen(name
, "r");
1355 fscanf(f
, "%u", &r
);
1359 sprintf(name
, cache_info
, i
, j
, "ways_of_associativity");
1360 f
= fopen(name
, "r");
1362 fscanf(f
, "%u", &r
);
1364 cache
.Associativity
= r
;
1366 sprintf(name
, cache_info
, i
, j
, "coherency_line_size");
1367 f
= fopen(name
, "r");
1369 fscanf(f
, "%u", &r
);
1373 sprintf(name
, cache_info
, i
, j
, "size");
1374 f
= fopen(name
, "r");
1376 fscanf(f
, "%u%c", &r
, &op
);
1379 WARN("unknown cache size %u%c\n", r
, op
);
1380 cache
.Size
= (op
=='K' ? r
*1024 : r
);
1382 sprintf(name
, cache_info
, i
, j
, "type");
1383 f
= fopen(name
, "r");
1385 fscanf(f
, "%s", name
);
1387 if(!memcmp(name
, "Data", 5))
1388 cache
.Type
= CacheData
;
1389 else if(!memcmp(name
, "Instruction", 11))
1390 cache
.Type
= CacheInstruction
;
1392 cache
.Type
= CacheUnified
;
1394 if(!logical_proc_info_add_cache(*data
, &len
, *max_len
, mask
, &cache
))
1396 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*new_data
;
1399 new_data
= RtlReAllocateHeap(GetProcessHeap(), 0, *data
, *max_len
*sizeof(*new_data
));
1403 return STATUS_NO_MEMORY
;
1407 logical_proc_info_add_cache(*data
, &len
, *max_len
, mask
, &cache
);
1414 fnuma_list
= fopen("/sys/devices/system/node/online", "r");
1419 for(i
=0; i
<len
; i
++)
1420 if((*data
)[i
].Relationship
== RelationProcessorCore
)
1421 mask
|= (*data
)[i
].ProcessorMask
;
1425 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*new_data
;
1428 new_data
= RtlReAllocateHeap(GetProcessHeap(), 0, *data
, *max_len
*sizeof(*new_data
));
1430 return STATUS_NO_MEMORY
;
1434 logical_proc_info_add_numa_node(*data
, &len
, *max_len
, mask
, 0);
1438 while(!feof(fnuma_list
))
1440 if(!fscanf(fnuma_list
, "%u%c ", &beg
, &op
))
1442 if(op
== '-') fscanf(fnuma_list
, "%u%c ", &end
, &op
);
1445 for(i
=beg
; i
<=end
; i
++)
1449 sprintf(name
, numa_info
, i
);
1450 f
= fopen(name
, "r");
1454 if(!fscanf(f
, "%x%c ", &r
, &op
))
1456 mask
= (sizeof(ULONG_PTR
)>sizeof(int) ? mask
<<(8*sizeof(DWORD
)) : 0) + r
;
1462 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*new_data
;
1465 new_data
= RtlReAllocateHeap(GetProcessHeap(), 0, *data
, *max_len
*sizeof(*new_data
));
1469 return STATUS_NO_MEMORY
;
1474 logical_proc_info_add_numa_node(*data
, &len
, *max_len
, mask
, i
);
1480 *max_len
= len
* sizeof(**data
);
1481 return STATUS_SUCCESS
;
1483 #elif defined(__APPLE__)
1484 static NTSTATUS
create_logical_proc_info(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
**data
, DWORD
*max_len
)
1486 DWORD len
= 0, i
, j
, k
;
1487 DWORD cores_no
, lcpu_no
, lcpu_per_core
, cores_per_package
, assoc
;
1490 LONGLONG cache_size
, cache_line_size
, cache_sharing
[10];
1491 CACHE_DESCRIPTOR cache
[4];
1493 lcpu_no
= NtCurrentTeb()->Peb
->NumberOfProcessors
;
1495 size
= sizeof(cores_no
);
1496 if(sysctlbyname("machdep.cpu.core_count", &cores_no
, &size
, NULL
, 0))
1499 lcpu_per_core
= lcpu_no
/cores_no
;
1500 for(i
=0; i
<cores_no
; i
++)
1503 for(j
=lcpu_per_core
*i
; j
<lcpu_per_core
*(i
+1); j
++)
1504 mask
|= (ULONG_PTR
)1<<j
;
1506 (*data
)[len
].Relationship
= RelationProcessorCore
;
1507 (*data
)[len
].ProcessorMask
= mask
;
1508 (*data
)[len
].u
.ProcessorCore
.Flags
= 0; /* TODO */
1512 size
= sizeof(cores_per_package
);
1513 if(sysctlbyname("machdep.cpu.cores_per_package", &cores_per_package
, &size
, NULL
, 0))
1514 cores_per_package
= lcpu_no
;
1516 for(i
=0; i
<(lcpu_no
+cores_per_package
-1)/cores_per_package
; i
++)
1519 for(j
=cores_per_package
*i
; j
<cores_per_package
*(i
+1) && j
<lcpu_no
; j
++)
1520 mask
|= (ULONG_PTR
)1<<j
;
1522 (*data
)[len
].Relationship
= RelationProcessorPackage
;
1523 (*data
)[len
].ProcessorMask
= mask
;
1527 memset(cache
, 0, sizeof(cache
));
1529 cache
[0].Type
= CacheInstruction
;
1531 cache
[1].Type
= CacheData
;
1533 cache
[2].Type
= CacheUnified
;
1535 cache
[3].Type
= CacheUnified
;
1537 size
= sizeof(cache_line_size
);
1538 if(!sysctlbyname("hw.cachelinesize", &cache_line_size
, &size
, NULL
, 0))
1541 cache
[i
].LineSize
= cache_line_size
;
1544 /* TODO: set associativity for all caches */
1545 size
= sizeof(assoc
);
1546 if(!sysctlbyname("machdep.cpu.cache.L2_associativity", &assoc
, &size
, NULL
, 0))
1547 cache
[2].Associativity
= assoc
;
1549 size
= sizeof(cache_size
);
1550 if(!sysctlbyname("hw.l1icachesize", &cache_size
, &size
, NULL
, 0))
1551 cache
[0].Size
= cache_size
;
1552 size
= sizeof(cache_size
);
1553 if(!sysctlbyname("hw.l1dcachesize", &cache_size
, &size
, NULL
, 0))
1554 cache
[1].Size
= cache_size
;
1555 size
= sizeof(cache_size
);
1556 if(!sysctlbyname("hw.l2cachesize", &cache_size
, &size
, NULL
, 0))
1557 cache
[2].Size
= cache_size
;
1558 size
= sizeof(cache_size
);
1559 if(!sysctlbyname("hw.l3cachesize", &cache_size
, &size
, NULL
, 0))
1560 cache
[3].Size
= cache_size
;
1562 size
= sizeof(cache_sharing
);
1563 if(!sysctlbyname("hw.cacheconfig", cache_sharing
, &size
, NULL
, 0))
1565 for(i
=1; i
<4 && i
<size
/sizeof(*cache_sharing
); i
++)
1567 if(!cache_sharing
[i
] || !cache
[i
].Size
)
1570 for(j
=0; j
<lcpu_no
/cache_sharing
[i
]; j
++)
1573 for(k
=j
*cache_sharing
[i
]; k
<lcpu_no
&& k
<(j
+1)*cache_sharing
[i
]; k
++)
1574 mask
|= (ULONG_PTR
)1<<k
;
1576 if(i
==1 && cache
[0].Size
)
1578 (*data
)[len
].Relationship
= RelationCache
;
1579 (*data
)[len
].ProcessorMask
= mask
;
1580 (*data
)[len
].u
.Cache
= cache
[0];
1584 (*data
)[len
].Relationship
= RelationCache
;
1585 (*data
)[len
].ProcessorMask
= mask
;
1586 (*data
)[len
].u
.Cache
= cache
[i
];
1593 for(i
=0; i
<lcpu_no
; i
++)
1594 mask
|= (ULONG_PTR
)1<<i
;
1595 (*data
)[len
].Relationship
= RelationNumaNode
;
1596 (*data
)[len
].ProcessorMask
= mask
;
1597 (*data
)[len
].u
.NumaNode
.NodeNumber
= 0;
1600 *max_len
= len
* sizeof(**data
);
1601 return STATUS_SUCCESS
;
1604 static NTSTATUS
create_logical_proc_info(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
**data
, DWORD
*max_len
)
1607 return STATUS_NOT_IMPLEMENTED
;
1611 /******************************************************************************
1612 * NtQuerySystemInformation [NTDLL.@]
1613 * ZwQuerySystemInformation [NTDLL.@]
1616 * SystemInformationClass Index to a certain information structure
1617 * SystemTimeAdjustmentInformation SYSTEM_TIME_ADJUSTMENT
1618 * SystemCacheInformation SYSTEM_CACHE_INFORMATION
1619 * SystemConfigurationInformation CONFIGURATION_INFORMATION
1620 * observed (class/len):
1626 * SystemInformation caller supplies storage for the information structure
1627 * Length size of the structure
1628 * ResultLength Data written
1630 NTSTATUS WINAPI
NtQuerySystemInformation(
1631 IN SYSTEM_INFORMATION_CLASS SystemInformationClass
,
1632 OUT PVOID SystemInformation
,
1634 OUT PULONG ResultLength
)
1636 NTSTATUS ret
= STATUS_SUCCESS
;
1639 TRACE("(0x%08x,%p,0x%08x,%p)\n",
1640 SystemInformationClass
,SystemInformation
,Length
,ResultLength
);
1642 switch (SystemInformationClass
)
1644 case SystemBasicInformation
:
1646 SYSTEM_BASIC_INFORMATION sbi
;
1648 virtual_get_system_info( &sbi
);
1653 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1654 else memcpy( SystemInformation
, &sbi
, len
);
1656 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1659 case SystemCpuInformation
:
1660 if (Length
>= (len
= sizeof(cached_sci
)))
1662 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1663 else memcpy(SystemInformation
, &cached_sci
, len
);
1665 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1667 case SystemPerformanceInformation
:
1669 SYSTEM_PERFORMANCE_INFORMATION spi
;
1670 static BOOL fixme_written
= FALSE
;
1673 memset(&spi
, 0 , sizeof(spi
));
1676 spi
.Reserved3
= 0x7fffffff; /* Available paged pool memory? */
1678 if ((fp
= fopen("/proc/uptime", "r")))
1680 double uptime
, idle_time
;
1682 fscanf(fp
, "%lf %lf", &uptime
, &idle_time
);
1684 spi
.IdleTime
.QuadPart
= 10000000 * idle_time
;
1688 static ULONGLONG idle
;
1689 /* many programs expect IdleTime to change so fake change */
1690 spi
.IdleTime
.QuadPart
= ++idle
;
1695 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1696 else memcpy( SystemInformation
, &spi
, len
);
1698 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1699 if(!fixme_written
) {
1700 FIXME("info_class SYSTEM_PERFORMANCE_INFORMATION\n");
1701 fixme_written
= TRUE
;
1705 case SystemTimeOfDayInformation
:
1707 SYSTEM_TIMEOFDAY_INFORMATION sti
;
1709 memset(&sti
, 0 , sizeof(sti
));
1711 /* liKeSystemTime, liExpTimeZoneBias, uCurrentTimeZoneId */
1712 sti
.liKeBootTime
.QuadPart
= server_start_time
;
1714 if (Length
<= sizeof(sti
))
1717 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1718 else memcpy( SystemInformation
, &sti
, Length
);
1720 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1723 case SystemProcessInformation
:
1725 SYSTEM_PROCESS_INFORMATION
* spi
= SystemInformation
;
1726 SYSTEM_PROCESS_INFORMATION
* last
= NULL
;
1728 WCHAR procname
[1024];
1731 DWORD procstructlen
= 0;
1733 SERVER_START_REQ( create_snapshot
)
1735 req
->flags
= SNAP_PROCESS
| SNAP_THREAD
;
1736 req
->attributes
= 0;
1737 if (!(ret
= wine_server_call( req
)))
1738 hSnap
= wine_server_ptr_handle( reply
->handle
);
1742 while (ret
== STATUS_SUCCESS
)
1744 SERVER_START_REQ( next_process
)
1746 req
->handle
= wine_server_obj_handle( hSnap
);
1747 req
->reset
= (len
== 0);
1748 wine_server_set_reply( req
, procname
, sizeof(procname
)-sizeof(WCHAR
) );
1749 if (!(ret
= wine_server_call( req
)))
1751 /* Make sure procname is 0 terminated */
1752 procname
[wine_server_reply_size(reply
) / sizeof(WCHAR
)] = 0;
1754 /* Get only the executable name, not the path */
1755 if ((exename
= strrchrW(procname
, '\\')) != NULL
) exename
++;
1756 else exename
= procname
;
1758 wlen
= (strlenW(exename
) + 1) * sizeof(WCHAR
);
1760 procstructlen
= sizeof(*spi
) + wlen
+ ((reply
->threads
- 1) * sizeof(SYSTEM_THREAD_INFORMATION
));
1762 if (Length
>= len
+ procstructlen
)
1764 /* ftCreationTime, ftUserTime, ftKernelTime;
1765 * vmCounters, ioCounters
1768 memset(spi
, 0, sizeof(*spi
));
1770 spi
->NextEntryOffset
= procstructlen
- wlen
;
1771 spi
->dwThreadCount
= reply
->threads
;
1773 /* spi->pszProcessName will be set later on */
1775 spi
->dwBasePriority
= reply
->priority
;
1776 spi
->UniqueProcessId
= UlongToHandle(reply
->pid
);
1777 spi
->ParentProcessId
= UlongToHandle(reply
->ppid
);
1778 spi
->HandleCount
= reply
->handles
;
1780 /* spi->ti will be set later on */
1783 len
+= procstructlen
;
1788 if (ret
!= STATUS_SUCCESS
)
1790 if (ret
== STATUS_NO_MORE_FILES
) ret
= STATUS_SUCCESS
;
1798 /* set thread info */
1800 while (ret
== STATUS_SUCCESS
)
1802 SERVER_START_REQ( next_thread
)
1804 req
->handle
= wine_server_obj_handle( hSnap
);
1805 req
->reset
= (j
== 0);
1806 if (!(ret
= wine_server_call( req
)))
1809 if (UlongToHandle(reply
->pid
) == spi
->UniqueProcessId
)
1811 /* ftKernelTime, ftUserTime, ftCreateTime;
1812 * dwTickCount, dwStartAddress
1815 memset(&spi
->ti
[i
], 0, sizeof(spi
->ti
));
1817 spi
->ti
[i
].CreateTime
.QuadPart
= 0xdeadbeef;
1818 spi
->ti
[i
].ClientId
.UniqueProcess
= UlongToHandle(reply
->pid
);
1819 spi
->ti
[i
].ClientId
.UniqueThread
= UlongToHandle(reply
->tid
);
1820 spi
->ti
[i
].dwCurrentPriority
= reply
->base_pri
+ reply
->delta_pri
;
1821 spi
->ti
[i
].dwBasePriority
= reply
->base_pri
;
1828 if (ret
== STATUS_NO_MORE_FILES
) ret
= STATUS_SUCCESS
;
1830 /* now append process name */
1831 spi
->ProcessName
.Buffer
= (WCHAR
*)((char*)spi
+ spi
->NextEntryOffset
);
1832 spi
->ProcessName
.Length
= wlen
- sizeof(WCHAR
);
1833 spi
->ProcessName
.MaximumLength
= wlen
;
1834 memcpy( spi
->ProcessName
.Buffer
, exename
, wlen
);
1835 spi
->NextEntryOffset
+= wlen
;
1838 spi
= (SYSTEM_PROCESS_INFORMATION
*)((char*)spi
+ spi
->NextEntryOffset
);
1841 if (ret
== STATUS_SUCCESS
&& last
) last
->NextEntryOffset
= 0;
1842 if (len
> Length
) ret
= STATUS_INFO_LENGTH_MISMATCH
;
1843 if (hSnap
) NtClose(hSnap
);
1846 case SystemProcessorPerformanceInformation
:
1848 SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
*sppi
= NULL
;
1849 unsigned int cpus
= 0;
1850 int out_cpus
= Length
/ sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
);
1855 ret
= STATUS_INFO_LENGTH_MISMATCH
;
1861 processor_cpu_load_info_data_t
*pinfo
;
1862 mach_msg_type_number_t info_count
;
1864 if (host_processor_info (mach_host_self (),
1865 PROCESSOR_CPU_LOAD_INFO
,
1867 (processor_info_array_t
*)&pinfo
,
1871 cpus
= min(cpus
,out_cpus
);
1872 len
= sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
) * cpus
;
1873 sppi
= RtlAllocateHeap(GetProcessHeap(), 0,len
);
1874 for (i
= 0; i
< cpus
; i
++)
1876 sppi
[i
].IdleTime
.QuadPart
= pinfo
[i
].cpu_ticks
[CPU_STATE_IDLE
];
1877 sppi
[i
].KernelTime
.QuadPart
= pinfo
[i
].cpu_ticks
[CPU_STATE_SYSTEM
];
1878 sppi
[i
].UserTime
.QuadPart
= pinfo
[i
].cpu_ticks
[CPU_STATE_USER
];
1880 vm_deallocate (mach_task_self (), (vm_address_t
) pinfo
, info_count
* sizeof(natural_t
));
1885 FILE *cpuinfo
= fopen("/proc/stat", "r");
1888 unsigned long clk_tck
= sysconf(_SC_CLK_TCK
);
1889 unsigned long usr
,nice
,sys
,idle
,remainder
[8];
1894 /* first line is combined usage */
1895 while (fgets(line
,255,cpuinfo
))
1897 count
= sscanf(line
, "%s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
1898 name
, &usr
, &nice
, &sys
, &idle
,
1899 &remainder
[0], &remainder
[1], &remainder
[2], &remainder
[3],
1900 &remainder
[4], &remainder
[5], &remainder
[6], &remainder
[7]);
1902 if (count
< 5 || strncmp( name
, "cpu", 3 )) break;
1903 for (i
= 0; i
+ 5 < count
; ++i
) sys
+= remainder
[i
];
1906 cpus
= atoi( name
+ 3 ) + 1;
1907 if (cpus
> out_cpus
) break;
1908 len
= sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
) * cpus
;
1910 sppi
= RtlReAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, sppi
, len
);
1912 sppi
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, len
);
1914 sppi
[cpus
-1].IdleTime
.QuadPart
= (ULONGLONG
)idle
* 10000000 / clk_tck
;
1915 sppi
[cpus
-1].KernelTime
.QuadPart
= (ULONGLONG
)sys
* 10000000 / clk_tck
;
1916 sppi
[cpus
-1].UserTime
.QuadPart
= (ULONGLONG
)usr
* 10000000 / clk_tck
;
1927 cpus
= min(NtCurrentTeb()->Peb
->NumberOfProcessors
, out_cpus
);
1928 len
= sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
) * cpus
;
1929 sppi
= RtlAllocateHeap(GetProcessHeap(), 0, len
);
1930 FIXME("stub info_class SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION\n");
1931 /* many programs expect these values to change so fake change */
1932 for (n
= 0; n
< cpus
; n
++)
1934 sppi
[n
].KernelTime
.QuadPart
= 1 * i
;
1935 sppi
[n
].UserTime
.QuadPart
= 2 * i
;
1936 sppi
[n
].IdleTime
.QuadPart
= 3 * i
;
1943 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1944 else memcpy( SystemInformation
, sppi
, len
);
1946 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1948 RtlFreeHeap(GetProcessHeap(),0,sppi
);
1951 case SystemModuleInformation
:
1952 /* FIXME: should be system-wide */
1953 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1954 else ret
= LdrQueryProcessModuleInformation( SystemInformation
, Length
, &len
);
1956 case SystemHandleInformation
:
1958 SYSTEM_HANDLE_INFORMATION shi
;
1960 memset(&shi
, 0, sizeof(shi
));
1965 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1966 else memcpy( SystemInformation
, &shi
, len
);
1968 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1969 FIXME("info_class SYSTEM_HANDLE_INFORMATION\n");
1972 case SystemCacheInformation
:
1974 SYSTEM_CACHE_INFORMATION sci
;
1976 memset(&sci
, 0, sizeof(sci
)); /* FIXME */
1981 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1982 else memcpy( SystemInformation
, &sci
, len
);
1984 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1985 FIXME("info_class SYSTEM_CACHE_INFORMATION\n");
1988 case SystemInterruptInformation
:
1990 SYSTEM_INTERRUPT_INFORMATION sii
;
1992 memset(&sii
, 0, sizeof(sii
));
1997 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1998 else memcpy( SystemInformation
, &sii
, len
);
2000 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
2001 FIXME("info_class SYSTEM_INTERRUPT_INFORMATION\n");
2004 case SystemKernelDebuggerInformation
:
2006 SYSTEM_KERNEL_DEBUGGER_INFORMATION skdi
;
2008 skdi
.DebuggerEnabled
= FALSE
;
2009 skdi
.DebuggerNotPresent
= TRUE
;
2014 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
2015 else memcpy( SystemInformation
, &skdi
, len
);
2017 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
2020 case SystemRegistryQuotaInformation
:
2022 /* Something to do with the size of the registry *
2023 * Since we don't have a size limitation, fake it *
2024 * This is almost certainly wrong. *
2025 * This sets each of the three words in the struct to 32 MB, *
2026 * which is enough to make the IE 5 installer happy. */
2027 SYSTEM_REGISTRY_QUOTA_INFORMATION srqi
;
2029 srqi
.RegistryQuotaAllowed
= 0x2000000;
2030 srqi
.RegistryQuotaUsed
= 0x200000;
2031 srqi
.Reserved1
= (void*)0x200000;
2036 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
2039 FIXME("SystemRegistryQuotaInformation: faking max registry size of 32 MB\n");
2040 memcpy( SystemInformation
, &srqi
, len
);
2043 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
2046 case SystemLogicalProcessorInformation
:
2048 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*buf
;
2050 /* Each logical processor may use up to 7 entries in returned table:
2051 * core, numa node, package, L1i, L1d, L2, L3 */
2052 len
= 7 * NtCurrentTeb()->Peb
->NumberOfProcessors
;
2053 buf
= RtlAllocateHeap(GetProcessHeap(), 0, len
* sizeof(*buf
));
2056 ret
= STATUS_NO_MEMORY
;
2060 ret
= create_logical_proc_info(&buf
, &len
);
2061 if( ret
!= STATUS_SUCCESS
)
2063 RtlFreeHeap(GetProcessHeap(), 0, buf
);
2069 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
2070 else memcpy( SystemInformation
, buf
, len
);
2072 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
2073 RtlFreeHeap(GetProcessHeap(), 0, buf
);
2077 FIXME("(0x%08x,%p,0x%08x,%p) stub\n",
2078 SystemInformationClass
,SystemInformation
,Length
,ResultLength
);
2080 /* Several Information Classes are not implemented on Windows and return 2 different values
2081 * STATUS_NOT_IMPLEMENTED or STATUS_INVALID_INFO_CLASS
2082 * in 95% of the cases it's STATUS_INVALID_INFO_CLASS, so use this as the default
2084 ret
= STATUS_INVALID_INFO_CLASS
;
2087 if (ResultLength
) *ResultLength
= len
;
2092 /******************************************************************************
2093 * NtSetSystemInformation [NTDLL.@]
2094 * ZwSetSystemInformation [NTDLL.@]
2096 NTSTATUS WINAPI
NtSetSystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass
, PVOID SystemInformation
, ULONG Length
)
2098 FIXME("(0x%08x,%p,0x%08x) stub\n",SystemInformationClass
,SystemInformation
,Length
);
2099 return STATUS_SUCCESS
;
2102 /******************************************************************************
2103 * NtCreatePagingFile [NTDLL.@]
2104 * ZwCreatePagingFile [NTDLL.@]
2106 NTSTATUS WINAPI
NtCreatePagingFile(
2107 PUNICODE_STRING PageFileName
,
2108 PLARGE_INTEGER MinimumSize
,
2109 PLARGE_INTEGER MaximumSize
,
2110 PLARGE_INTEGER ActualSize
)
2112 FIXME("(%p %p %p %p) stub\n", PageFileName
, MinimumSize
, MaximumSize
, ActualSize
);
2113 return STATUS_SUCCESS
;
2116 /******************************************************************************
2117 * NtDisplayString [NTDLL.@]
2119 * writes a string to the nt-textmode screen eg. during startup
2121 NTSTATUS WINAPI
NtDisplayString ( PUNICODE_STRING string
)
2126 if (!(ret
= RtlUnicodeStringToAnsiString( &stringA
, string
, TRUE
)))
2128 MESSAGE( "%.*s", stringA
.Length
, stringA
.Buffer
);
2129 RtlFreeAnsiString( &stringA
);
2134 /******************************************************************************
2135 * NtInitiatePowerAction [NTDLL.@]
2138 NTSTATUS WINAPI
NtInitiatePowerAction(
2139 IN POWER_ACTION SystemAction
,
2140 IN SYSTEM_POWER_STATE MinSystemState
,
2142 IN BOOLEAN Asynchronous
)
2144 FIXME("(%d,%d,0x%08x,%d),stub\n",
2145 SystemAction
,MinSystemState
,Flags
,Asynchronous
);
2146 return STATUS_NOT_IMPLEMENTED
;
2150 /* Fallback using /proc/cpuinfo for Linux systems without cpufreq. For
2151 * most distributions on recent enough hardware, this is only likely to
2152 * happen while running in virtualized environments such as QEMU. */
2153 static ULONG
mhz_from_cpuinfo(void)
2158 FILE* f
= fopen("/proc/cpuinfo", "r");
2160 while (fgets(line
, sizeof(line
), f
) != NULL
) {
2161 if (!(value
= strchr(line
,':')))
2164 while ((s
>= line
) && isspace(*s
)) s
--;
2167 if (!strcasecmp(line
, "cpu MHz")) {
2168 sscanf(value
, " %lf", &cmz
);
2178 /******************************************************************************
2179 * NtPowerInformation [NTDLL.@]
2182 NTSTATUS WINAPI
NtPowerInformation(
2183 IN POWER_INFORMATION_LEVEL InformationLevel
,
2184 IN PVOID lpInputBuffer
,
2185 IN ULONG nInputBufferSize
,
2186 IN PVOID lpOutputBuffer
,
2187 IN ULONG nOutputBufferSize
)
2189 TRACE("(%d,%p,%d,%p,%d)\n",
2190 InformationLevel
,lpInputBuffer
,nInputBufferSize
,lpOutputBuffer
,nOutputBufferSize
);
2191 switch(InformationLevel
) {
2192 case SystemPowerCapabilities
: {
2193 PSYSTEM_POWER_CAPABILITIES PowerCaps
= lpOutputBuffer
;
2194 FIXME("semi-stub: SystemPowerCapabilities\n");
2195 if (nOutputBufferSize
< sizeof(SYSTEM_POWER_CAPABILITIES
))
2196 return STATUS_BUFFER_TOO_SMALL
;
2197 /* FIXME: These values are based off a native XP desktop, should probably use APM/ACPI to get the 'real' values */
2198 PowerCaps
->PowerButtonPresent
= TRUE
;
2199 PowerCaps
->SleepButtonPresent
= FALSE
;
2200 PowerCaps
->LidPresent
= FALSE
;
2201 PowerCaps
->SystemS1
= TRUE
;
2202 PowerCaps
->SystemS2
= FALSE
;
2203 PowerCaps
->SystemS3
= FALSE
;
2204 PowerCaps
->SystemS4
= TRUE
;
2205 PowerCaps
->SystemS5
= TRUE
;
2206 PowerCaps
->HiberFilePresent
= TRUE
;
2207 PowerCaps
->FullWake
= TRUE
;
2208 PowerCaps
->VideoDimPresent
= FALSE
;
2209 PowerCaps
->ApmPresent
= FALSE
;
2210 PowerCaps
->UpsPresent
= FALSE
;
2211 PowerCaps
->ThermalControl
= FALSE
;
2212 PowerCaps
->ProcessorThrottle
= FALSE
;
2213 PowerCaps
->ProcessorMinThrottle
= 100;
2214 PowerCaps
->ProcessorMaxThrottle
= 100;
2215 PowerCaps
->DiskSpinDown
= TRUE
;
2216 PowerCaps
->SystemBatteriesPresent
= FALSE
;
2217 PowerCaps
->BatteriesAreShortTerm
= FALSE
;
2218 PowerCaps
->BatteryScale
[0].Granularity
= 0;
2219 PowerCaps
->BatteryScale
[0].Capacity
= 0;
2220 PowerCaps
->BatteryScale
[1].Granularity
= 0;
2221 PowerCaps
->BatteryScale
[1].Capacity
= 0;
2222 PowerCaps
->BatteryScale
[2].Granularity
= 0;
2223 PowerCaps
->BatteryScale
[2].Capacity
= 0;
2224 PowerCaps
->AcOnLineWake
= PowerSystemUnspecified
;
2225 PowerCaps
->SoftLidWake
= PowerSystemUnspecified
;
2226 PowerCaps
->RtcWake
= PowerSystemSleeping1
;
2227 PowerCaps
->MinDeviceWakeState
= PowerSystemUnspecified
;
2228 PowerCaps
->DefaultLowLatencyWake
= PowerSystemUnspecified
;
2229 return STATUS_SUCCESS
;
2231 case SystemExecutionState
: {
2232 PULONG ExecutionState
= lpOutputBuffer
;
2233 WARN("semi-stub: SystemExecutionState\n"); /* Needed for .NET Framework, but using a FIXME is really noisy. */
2234 if (lpInputBuffer
!= NULL
)
2235 return STATUS_INVALID_PARAMETER
;
2236 /* FIXME: The actual state should be the value set by SetThreadExecutionState which is not currently implemented. */
2237 *ExecutionState
= ES_USER_PRESENT
;
2238 return STATUS_SUCCESS
;
2240 case ProcessorInformation
: {
2241 const int cannedMHz
= 1000; /* We fake a 1GHz processor if we can't conjure up real values */
2242 PROCESSOR_POWER_INFORMATION
* cpu_power
= lpOutputBuffer
;
2245 if ((lpOutputBuffer
== NULL
) || (nOutputBufferSize
== 0))
2246 return STATUS_INVALID_PARAMETER
;
2247 out_cpus
= NtCurrentTeb()->Peb
->NumberOfProcessors
;
2248 if ((nOutputBufferSize
/ sizeof(PROCESSOR_POWER_INFORMATION
)) < out_cpus
)
2249 return STATUS_BUFFER_TOO_SMALL
;
2255 for(i
= 0; i
< out_cpus
; i
++) {
2256 sprintf(filename
, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_cur_freq", i
);
2257 f
= fopen(filename
, "r");
2258 if (f
&& (fscanf(f
, "%d", &cpu_power
[i
].CurrentMhz
) == 1)) {
2259 cpu_power
[i
].CurrentMhz
/= 1000;
2264 cpu_power
[0].CurrentMhz
= mhz_from_cpuinfo();
2265 if(cpu_power
[0].CurrentMhz
== 0)
2266 cpu_power
[0].CurrentMhz
= cannedMHz
;
2269 cpu_power
[i
].CurrentMhz
= cpu_power
[0].CurrentMhz
;
2273 sprintf(filename
, "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", i
);
2274 f
= fopen(filename
, "r");
2275 if (f
&& (fscanf(f
, "%d", &cpu_power
[i
].MaxMhz
) == 1)) {
2276 cpu_power
[i
].MaxMhz
/= 1000;
2280 cpu_power
[i
].MaxMhz
= cpu_power
[i
].CurrentMhz
;
2284 sprintf(filename
, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_max_freq", i
);
2285 f
= fopen(filename
, "r");
2286 if(f
&& (fscanf(f
, "%d", &cpu_power
[i
].MhzLimit
) == 1)) {
2287 cpu_power
[i
].MhzLimit
/= 1000;
2292 cpu_power
[i
].MhzLimit
= cpu_power
[i
].MaxMhz
;
2296 cpu_power
[i
].Number
= i
;
2297 cpu_power
[i
].MaxIdleState
= 0; /* FIXME */
2298 cpu_power
[i
].CurrentIdleState
= 0; /* FIXME */
2301 #elif defined(__FreeBSD__) || defined (__FreeBSD_kernel__) || defined(__DragonFly__)
2304 size_t valSize
= sizeof(num
);
2305 if (sysctlbyname("hw.clockrate", &num
, &valSize
, NULL
, 0))
2307 for(i
= 0; i
< out_cpus
; i
++) {
2308 cpu_power
[i
].CurrentMhz
= num
;
2309 cpu_power
[i
].MaxMhz
= num
;
2310 cpu_power
[i
].MhzLimit
= num
;
2311 cpu_power
[i
].Number
= i
;
2312 cpu_power
[i
].MaxIdleState
= 0; /* FIXME */
2313 cpu_power
[i
].CurrentIdleState
= 0; /* FIXME */
2316 #elif defined (__APPLE__)
2319 unsigned long long currentMhz
;
2320 unsigned long long maxMhz
;
2322 valSize
= sizeof(currentMhz
);
2323 if (!sysctlbyname("hw.cpufrequency", ¤tMhz
, &valSize
, NULL
, 0))
2324 currentMhz
/= 1000000;
2326 currentMhz
= cannedMHz
;
2328 valSize
= sizeof(maxMhz
);
2329 if (!sysctlbyname("hw.cpufrequency_max", &maxMhz
, &valSize
, NULL
, 0))
2332 maxMhz
= currentMhz
;
2334 for(i
= 0; i
< out_cpus
; i
++) {
2335 cpu_power
[i
].CurrentMhz
= currentMhz
;
2336 cpu_power
[i
].MaxMhz
= maxMhz
;
2337 cpu_power
[i
].MhzLimit
= maxMhz
;
2338 cpu_power
[i
].Number
= i
;
2339 cpu_power
[i
].MaxIdleState
= 0; /* FIXME */
2340 cpu_power
[i
].CurrentIdleState
= 0; /* FIXME */
2344 for(i
= 0; i
< out_cpus
; i
++) {
2345 cpu_power
[i
].CurrentMhz
= cannedMHz
;
2346 cpu_power
[i
].MaxMhz
= cannedMHz
;
2347 cpu_power
[i
].MhzLimit
= cannedMHz
;
2348 cpu_power
[i
].Number
= i
;
2349 cpu_power
[i
].MaxIdleState
= 0; /* FIXME */
2350 cpu_power
[i
].CurrentIdleState
= 0; /* FIXME */
2352 WARN("Unable to detect CPU MHz for this platform. Reporting %d MHz.\n", cannedMHz
);
2354 for(i
= 0; i
< out_cpus
; i
++) {
2355 TRACE("cpu_power[%d] = %u %u %u %u %u %u\n", i
, cpu_power
[i
].Number
,
2356 cpu_power
[i
].MaxMhz
, cpu_power
[i
].CurrentMhz
, cpu_power
[i
].MhzLimit
,
2357 cpu_power
[i
].MaxIdleState
, cpu_power
[i
].CurrentIdleState
);
2359 return STATUS_SUCCESS
;
2362 /* FIXME: Needed by .NET Framework */
2363 WARN("Unimplemented NtPowerInformation action: %d\n", InformationLevel
);
2364 return STATUS_NOT_IMPLEMENTED
;
2368 /******************************************************************************
2369 * NtShutdownSystem [NTDLL.@]
2372 NTSTATUS WINAPI
NtShutdownSystem(SHUTDOWN_ACTION Action
)
2374 FIXME("%d\n",Action
);
2375 return STATUS_SUCCESS
;
2378 /******************************************************************************
2379 * NtAllocateLocallyUniqueId (NTDLL.@)
2381 NTSTATUS WINAPI
NtAllocateLocallyUniqueId(PLUID Luid
)
2385 TRACE("%p\n", Luid
);
2388 return STATUS_ACCESS_VIOLATION
;
2390 SERVER_START_REQ( allocate_locally_unique_id
)
2392 status
= wine_server_call( req
);
2395 Luid
->LowPart
= reply
->luid
.low_part
;
2396 Luid
->HighPart
= reply
->luid
.high_part
;
2404 /******************************************************************************
2405 * VerSetConditionMask (NTDLL.@)
2407 ULONGLONG WINAPI
VerSetConditionMask( ULONGLONG dwlConditionMask
, DWORD dwTypeBitMask
,
2408 BYTE dwConditionMask
)
2410 if(dwTypeBitMask
== 0)
2411 return dwlConditionMask
;
2412 dwConditionMask
&= 0x07;
2413 if(dwConditionMask
== 0)
2414 return dwlConditionMask
;
2416 if(dwTypeBitMask
& VER_PRODUCT_TYPE
)
2417 dwlConditionMask
|= dwConditionMask
<< 7*3;
2418 else if (dwTypeBitMask
& VER_SUITENAME
)
2419 dwlConditionMask
|= dwConditionMask
<< 6*3;
2420 else if (dwTypeBitMask
& VER_SERVICEPACKMAJOR
)
2421 dwlConditionMask
|= dwConditionMask
<< 5*3;
2422 else if (dwTypeBitMask
& VER_SERVICEPACKMINOR
)
2423 dwlConditionMask
|= dwConditionMask
<< 4*3;
2424 else if (dwTypeBitMask
& VER_PLATFORMID
)
2425 dwlConditionMask
|= dwConditionMask
<< 3*3;
2426 else if (dwTypeBitMask
& VER_BUILDNUMBER
)
2427 dwlConditionMask
|= dwConditionMask
<< 2*3;
2428 else if (dwTypeBitMask
& VER_MAJORVERSION
)
2429 dwlConditionMask
|= dwConditionMask
<< 1*3;
2430 else if (dwTypeBitMask
& VER_MINORVERSION
)
2431 dwlConditionMask
|= dwConditionMask
<< 0*3;
2432 return dwlConditionMask
;
2435 /******************************************************************************
2436 * NtAccessCheckAndAuditAlarm (NTDLL.@)
2437 * ZwAccessCheckAndAuditAlarm (NTDLL.@)
2439 NTSTATUS WINAPI
NtAccessCheckAndAuditAlarm(PUNICODE_STRING SubsystemName
, HANDLE HandleId
, PUNICODE_STRING ObjectTypeName
,
2440 PUNICODE_STRING ObjectName
, PSECURITY_DESCRIPTOR SecurityDescriptor
,
2441 ACCESS_MASK DesiredAccess
, PGENERIC_MAPPING GenericMapping
, BOOLEAN ObjectCreation
,
2442 PACCESS_MASK GrantedAccess
, PBOOLEAN AccessStatus
, PBOOLEAN GenerateOnClose
)
2444 FIXME("(%s, %p, %s, %p, 0x%08x, %p, %d, %p, %p, %p), stub\n", debugstr_us(SubsystemName
), HandleId
,
2445 debugstr_us(ObjectTypeName
), SecurityDescriptor
, DesiredAccess
, GenericMapping
, ObjectCreation
,
2446 GrantedAccess
, AccessStatus
, GenerateOnClose
);
2448 return STATUS_NOT_IMPLEMENTED
;
2451 /******************************************************************************
2452 * NtSystemDebugControl (NTDLL.@)
2453 * ZwSystemDebugControl (NTDLL.@)
2455 NTSTATUS WINAPI
NtSystemDebugControl(SYSDBG_COMMAND command
, PVOID inbuffer
, ULONG inbuflength
, PVOID outbuffer
,
2456 ULONG outbuflength
, PULONG retlength
)
2458 FIXME("(%d, %p, %d, %p, %d, %p), stub\n", command
, inbuffer
, inbuflength
, outbuffer
, outbuflength
, retlength
);
2460 return STATUS_NOT_IMPLEMENTED
;