1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file tuklib_physmem.c
4 /// \brief Get the amount of physical memory
5 //
6 // Author: Lasse Collin
7 //
8 // This file has been put into the public domain.
9 // You can do whatever you want with this file.
10 //
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #include "tuklib_physmem.h"
14
15 // We want to use Windows-specific code on Cygwin, which also has memory
16 // information available via sysconf(), but on Cygwin 1.5 and older it
17 // gives wrong results (from our point of view).
18 #if defined(_WIN32) || defined(__CYGWIN__)
19 # ifndef _WIN32_WINNT
20 # define _WIN32_WINNT 0x0500
21 # endif
22 # include <windows.h>
23
24 #elif defined(__OS2__)
25 # define INCL_DOSMISC
26 # include <os2.h>
27
28 #elif defined(__DJGPP__)
29 # include <dpmi.h>
30
31 #elif defined(__VMS)
32 # include <lib$routines.h>
33 # include <syidef.h>
34 # include <ssdef.h>
35
36 #elif defined(AMIGA) || defined(__AROS__)
37 # define __USE_INLINE__
38 # include <proto/exec.h>
39
40 #elif defined(__QNX__)
41 # include <sys/syspage.h>
42 # include <string.h>
43
44 #elif defined(TUKLIB_PHYSMEM_AIX)
45 # include <sys/systemcfg.h>
46
47 #elif defined(TUKLIB_PHYSMEM_SYSCONF)
48 # include <unistd.h>
49
50 #elif defined(TUKLIB_PHYSMEM_SYSCTL)
51 # ifdef HAVE_SYS_PARAM_H
52 # include <sys/param.h>
53 # endif
54 # include <sys/sysctl.h>
55
56 // Tru64
57 #elif defined(TUKLIB_PHYSMEM_GETSYSINFO)
58 # include <sys/sysinfo.h>
59 # include <machine/hal_sysinfo.h>
60
61 // HP-UX
62 #elif defined(TUKLIB_PHYSMEM_PSTAT_GETSTATIC)
63 # include <sys/param.h>
64 # include <sys/pstat.h>
65
66 // IRIX
67 #elif defined(TUKLIB_PHYSMEM_GETINVENT_R)
68 # include <invent.h>
69
70 // This sysinfo() is Linux-specific.
71 #elif defined(TUKLIB_PHYSMEM_SYSINFO)
72 # include <sys/sysinfo.h>
73 #endif
74
75
76 // With GCC >= 8.1 with -Wextra and Clang >= 13 with -Wcast-function-type
77 // will warn about the Windows-specific code.
78 #if defined(__has_warning)
79 # if __has_warning("-Wcast-function-type")
80 # define CAN_DISABLE_WCAST_FUNCTION_TYPE 1
81 # endif
82 #elif TUKLIB_GNUC_REQ(8,1)
83 # define CAN_DISABLE_WCAST_FUNCTION_TYPE 1
84 #endif
85
86
87 extern uint64_t
88 tuklib_physmem(void)
89 {
90 uint64_t ret = 0;
91
92 #if defined(_WIN32) || defined(__CYGWIN__)
93 if ((GetVersion() & 0xFF) >= 5) {
94 // Windows 2000 and later have GlobalMemoryStatusEx() which
95 // supports reporting values greater than 4 GiB. To keep the
96 // code working also on older Windows versions, use
97 // GlobalMemoryStatusEx() conditionally.
98 HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
99 if (kernel32 != NULL) {
100 typedef BOOL (WINAPI *gmse_type)(LPMEMORYSTATUSEX);
101 #ifdef CAN_DISABLE_WCAST_FUNCTION_TYPE
102 # pragma GCC diagnostic push
103 # pragma GCC diagnostic ignored "-Wcast-function-type"
104 #endif
105 gmse_type gmse = (gmse_type)GetProcAddress(
106 kernel32, "GlobalMemoryStatusEx");
107 #ifdef CAN_DISABLE_WCAST_FUNCTION_TYPE
108 # pragma GCC diagnostic pop
109 #endif
110 if (gmse != NULL) {
111 MEMORYSTATUSEX meminfo;
112 meminfo.dwLength = sizeof(meminfo);
113 if (gmse(&meminfo))
114 ret = meminfo.ullTotalPhys;
115 }
116 }
117 }
118
119 if (ret == 0) {
120 // GlobalMemoryStatus() is supported by Windows 95 and later,
121 // so it is fine to link against it unconditionally. Note that
122 // GlobalMemoryStatus() has no return value.
123 MEMORYSTATUS meminfo;
124 meminfo.dwLength = sizeof(meminfo);
125 GlobalMemoryStatus(&meminfo);
126 ret = meminfo.dwTotalPhys;
127 }
128
129 #elif defined(__OS2__)
130 unsigned long mem;
131 if (DosQuerySysInfo(QSV_TOTPHYSMEM, QSV_TOTPHYSMEM,
132 &mem, sizeof(mem)) == 0)
133 ret = mem;
134
135 #elif defined(__DJGPP__)
136 __dpmi_free_mem_info meminfo;
137 if (__dpmi_get_free_memory_information(&meminfo) == 0
138 && meminfo.total_number_of_physical_pages
139 != (unsigned long)-1)
140 ret = (uint64_t)meminfo.total_number_of_physical_pages * 4096;
141
142 #elif defined(__VMS)
143 int vms_mem;
144 int val = SYI$_MEMSIZE;
145 if (LIB$GETSYI(&val, &vms_mem, 0, 0, 0, 0) == SS$_NORMAL)
146 ret = (uint64_t)vms_mem * 8192;
147
148 #elif defined(AMIGA) || defined(__AROS__)
149 ret = AvailMem(MEMF_TOTAL);
150
151 #elif defined(__QNX__)
152 const struct asinfo_entry *entries = SYSPAGE_ENTRY(asinfo);
153 size_t count = SYSPAGE_ENTRY_SIZE(asinfo) / sizeof(struct asinfo_entry);
154 const char *strings = SYSPAGE_ENTRY(strings)->data;
155
156 for (size_t i = 0; i < count; ++i)
157 if (strcmp(strings + entries[i].name, "ram") == 0)
158 ret += entries[i].end - entries[i].start + 1;
159
160 #elif defined(TUKLIB_PHYSMEM_AIX)
161 ret = _system_configuration.physmem;
162
163 #elif defined(TUKLIB_PHYSMEM_SYSCONF)
164 const long pagesize = sysconf(_SC_PAGESIZE);
165 const long pages = sysconf(_SC_PHYS_PAGES);
166 if (pagesize != -1 && pages != -1)
167 // According to docs, pagesize * pages can overflow.
168 // Simple case is 32-bit box with 4 GiB or more RAM,
169 // which may report exactly 4 GiB of RAM, and "long"
170 // being 32-bit will overflow. Casting to uint64_t
171 // hopefully avoids overflows in the near future.
172 ret = (uint64_t)pagesize * (uint64_t)pages;
173
174 #elif defined(TUKLIB_PHYSMEM_SYSCTL)
175 int name[2] = {
176 CTL_HW,
177 #ifdef HW_PHYSMEM64
178 HW_PHYSMEM64
179 #else
180 HW_PHYSMEM
181 #endif
182 };
183 union {
184 uint32_t u32;
185 uint64_t u64;
186 } mem;
187 size_t mem_ptr_size = sizeof(mem.u64);
188 if (sysctl(name, 2, &mem.u64, &mem_ptr_size, NULL, 0) != -1) {
189 // IIRC, 64-bit "return value" is possible on some 64-bit
190 // BSD systems even with HW_PHYSMEM (instead of HW_PHYSMEM64),
191 // so support both.
192 if (mem_ptr_size == sizeof(mem.u64))
193 ret = mem.u64;
194 else if (mem_ptr_size == sizeof(mem.u32))
195 ret = mem.u32;
196 }
197
198 #elif defined(TUKLIB_PHYSMEM_GETSYSINFO)
199 // Docs are unclear if "start" is needed, but it doesn't hurt
200 // much to have it.
201 int memkb;
202 int start = 0;
203 if (getsysinfo(GSI_PHYSMEM, (caddr_t)&memkb, sizeof(memkb), &start)
204 != -1)
205 ret = (uint64_t)memkb * 1024;
206
207 #elif defined(TUKLIB_PHYSMEM_PSTAT_GETSTATIC)
208 struct pst_static pst;
209 if (pstat_getstatic(&pst, sizeof(pst), 1, 0) != -1)
210 ret = (uint64_t)pst.physical_memory * (uint64_t)pst.page_size;
211
212 #elif defined(TUKLIB_PHYSMEM_GETINVENT_R)
213 inv_state_t *st = NULL;
214 if (setinvent_r(&st) != -1) {
215 inventory_t *i;
216 while ((i = getinvent_r(st)) != NULL) {
217 if (i->inv_class == INV_MEMORY
218 && i->inv_type == INV_MAIN_MB) {
219 ret = (uint64_t)i->inv_state << 20;
220 break;
221 }
222 }
223
224 endinvent_r(st);
225 }
226
227 #elif defined(TUKLIB_PHYSMEM_SYSINFO)
228 struct sysinfo si;
229 if (sysinfo(&si) == 0)
230 ret = (uint64_t)si.totalram * si.mem_unit;
231 #endif
232
233 return ret;
234 }