1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/** @file
* IPRT - System Information.
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
#ifndef ___iprt_system_h
#define ___iprt_system_h
#include <iprt/cdefs.h>
#include <iprt/types.h>
RT_C_DECLS_BEGIN
/** @defgroup grp_rt_system RTSystem - System Information
* @ingroup grp_rt
* @{
*/
/**
* Info level for RTSystemGetOSInfo().
*/
typedef enum RTSYSOSINFO
{
RTSYSOSINFO_INVALID = 0, /**< The usual invalid entry. */
RTSYSOSINFO_PRODUCT, /**< OS product name. (uname -o) */
RTSYSOSINFO_RELEASE, /**< OS release. (uname -r) */
RTSYSOSINFO_VERSION, /**< OS version, optional. (uname -v) */
RTSYSOSINFO_SERVICE_PACK, /**< Service/fix pack level, optional. */
RTSYSOSINFO_END /**< End of the valid info levels. */
} RTSYSOSINFO;
/**
* Queries information about the OS.
*
* @returns IPRT status code.
* @retval VINF_SUCCESS on success.
* @retval VERR_INVALID_PARAMETER if enmInfo is invalid.
* @retval VERR_INVALID_POINTER if pszInfoStr is invalid.
* @retval VERR_BUFFER_OVERFLOW if the buffer is too small. The buffer will
* contain the chopped off result in this case, provided cchInfo isn't 0.
* @retval VERR_NOT_SUPPORTED if the info level isn't implemented. The buffer will
* contain an empty string.
*
* @param enmInfo The OS info level.
* @param pszInfo Where to store the result.
* @param cchInfo The size of the output buffer.
*/
RTDECL(int) RTSystemQueryOSInfo(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo);
/**
* Queries the total amount of RAM in the system.
*
* This figure does not given any information about how much memory is
* currently available. Use RTSystemQueryAvailableRam instead.
*
* @returns IPRT status code.
* @retval VINF_SUCCESS and *pcb on sucess.
* @retval VERR_ACCESS_DENIED if the information isn't accessible to the
* caller.
*
* @param pcb Where to store the result (in bytes).
*/
RTDECL(int) RTSystemQueryTotalRam(uint64_t *pcb);
/**
* Queries the total amount of RAM accessible to the system.
*
* This figure should not include memory that is installed but not used,
* nor memory that will be slow to bring online. The definition of 'slow'
* here is slower than swapping out a MB of pages to disk.
*
* @returns IPRT status code.
* @retval VINF_SUCCESS and *pcb on success.
* @retval VERR_ACCESS_DENIED if the information isn't accessible to the
* caller.
*
* @param pcb Where to store the result (in bytes).
*/
RTDECL(int) RTSystemQueryAvailableRam(uint64_t *pcb);
/**
* Queries the amount of RAM that is currently locked down or in some other
* way made impossible to virtualize within reasonably short time.
*
* The purposes of this API is, when combined with RTSystemQueryTotalRam, to
* be able to determine an absolute max limit for how much fixed memory it is
* (theoretically) possible to allocate (or lock down).
*
* The kind memory covered by this function includes:
* - locked (wired) memory - like for instance RTR0MemObjLockUser
* and RTR0MemObjLockKernel makes,
* - kernel pools and heaps - like for instance the ring-0 variant
* of RTMemAlloc taps into,
* - fixed (not pageable) kernel allocations - like for instance
* all the RTR0MemObjAlloc* functions makes,
* - any similar memory that isn't easily swapped out, discarded,
* or flushed to disk.
*
* This works against the value returned by RTSystemQueryTotalRam, and
* the value reported by this function can never be larger than what a
* call to RTSystemQueryTotalRam returns.
*
* The short time term here is relative to swapping to disk like in
* RTSystemQueryTotalRam. This could mean that (part of) the dirty buffers
* in the dynamic I/O cache could be included in the total. If the dynamic
* I/O cache isn't likely to either flush buffers when the load increases
* and put them back into normal circulation, they should be included in
* the memory accounted for here.
*
* @retval VINF_SUCCESS and *pcb on success.
* @retval VERR_NOT_SUPPORTED if the information isn't available on the
* system in general. The caller must handle this scenario.
* @retval VERR_ACCESS_DENIED if the information isn't accessible to the
* caller.
*
* @param pcb Where to store the result (in bytes).
*
* @remarks This function could've been inverted and called
* RTSystemQueryAvailableRam, but that might give impression that
* it would be possible to allocate the amount of memory it
* indicates for a single purpose, something which would be very
* improbable on most systems.
*
* @remarks We might have to add another output parameter to this function
* that indicates if some of the memory kinds listed above cannot
* be accounted for on the system and therefore is not include in
* the returned amount.
*/
RTDECL(int) RTSystemQueryUnavailableRam(uint64_t *pcb);
/**
* The DMI strings.
*/
typedef enum RTSYSDMISTR
{
/** Invalid zero entry. */
RTSYSDMISTR_INVALID = 0,
/** The product name. */
RTSYSDMISTR_PRODUCT_NAME,
/** The product version. */
RTSYSDMISTR_PRODUCT_VERSION,
/** The product UUID. */
RTSYSDMISTR_PRODUCT_UUID,
/** The product serial. */
RTSYSDMISTR_PRODUCT_SERIAL,
/** The system manufacturer. */
RTSYSDMISTR_MANUFACTURER,
/** The end of the valid strings. */
RTSYSDMISTR_END,
/** The usual 32-bit hack. */
RTSYSDMISTR_32_BIT_HACK = 0x7fffffff
} RTSYSDMISTR;
/**
* Queries a DMI string.
*
* @returns IPRT status code.
* @retval VINF_SUCCESS on success.
* @retval VERR_BUFFER_OVERFLOW if the buffer is too small. The buffer will
* contain the chopped off result in this case, provided cbBuf isn't 0.
* @retval VERR_ACCESS_DENIED if the information isn't accessible to the
* caller.
* @retval VERR_NOT_SUPPORTED if the information isn't available on the system
* in general. The caller must expect this status code and deal with
* it.
*
* @param enmString Which string to query.
* @param pszBuf Where to store the string. This is always
* terminated, even on error.
* @param cbBuf The buffer size.
*/
RTDECL(int) RTSystemQueryDmiString(RTSYSDMISTR enmString, char *pszBuf, size_t cbBuf);
/** @name Flags for RTSystemReboot and RTSystemShutdown.
* @{ */
/** Reboot the system after shutdown. */
#define RTSYSTEM_SHUTDOWN_REBOOT UINT32_C(0)
/** Reboot the system after shutdown.
* The call may return VINF_SYS_MAY_POWER_OFF if the OS /
* hardware combination may power off instead of halting. */
#define RTSYSTEM_SHUTDOWN_HALT UINT32_C(1)
/** Power off the system after shutdown.
* This may be equvivalent to a RTSYSTEM_SHUTDOWN_HALT on systems where we
* cannot figure out whether the hardware/OS implements the actual powering
* off. If we can figure out that it's not supported, an
* VERR_SYS_CANNOT_POWER_OFF error is raised. */
#define RTSYSTEM_SHUTDOWN_POWER_OFF UINT32_C(2)
/** Power off the system after shutdown, or halt it if that's not possible. */
#define RTSYSTEM_SHUTDOWN_POWER_OFF_HALT UINT32_C(3)
/** The shutdown action mask. */
#define RTSYSTEM_SHUTDOWN_ACTION_MASK UINT32_C(3)
/** Unplanned shutdown/reboot. */
#define RTSYSTEM_SHUTDOWN_UNPLANNED UINT32_C(0)
/** Planned shutdown/reboot. */
#define RTSYSTEM_SHUTDOWN_PLANNED RT_BIT_32(2)
/** Force the system to shutdown/reboot regardless of objecting application
* or other stuff. This flag might not be realized on all systems. */
#define RTSYSTEM_SHUTDOWN_FORCE RT_BIT_32(3)
/** Parameter validation mask. */
#define RTSYSTEM_SHUTDOWN_VALID_MASK UINT32_C(0x0000000f)
/** @} */
/**
* Shuts down the system.
*
* @returns IPRT status code on failure, on success it may or may not return
* depending on the OS.
* @retval VINF_SUCCESS
* @retval VINF_SYS_MAY_POWER_OFF
* @retval VERR_SYS_SHUTDOWN_FAILED
* @retval VERR_SYS_CANNOT_POWER_OFF
*
* @param cMsDelay The delay before the actual reboot. If this is
* not supported by the OS, an immediate reboot
* will be performed.
* @param fFlags Shutdown flags, see RTSYSTEM_SHUTDOWN_XXX.
* @param pszLogMsg Message for the log and users about why we're
* shutting down.
*/
RTDECL(int) RTSystemShutdown(RTMSINTERVAL cMsDelay, uint32_t fFlags, const char *pszLogMsg);
/** @} */
RT_C_DECLS_END
#endif
|
