Accessing macOS System Information: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Overview
2	2
3	3		macOS provides four main ways to access system information:
4	4
5	5		- Sysctl interface - An interface used by Unix and Unix-like operating systems to access system hardware and kernel configuration attributes.
6	6		- NSProcessInfo class - A class in the Foundation framework which gives access to a collection of information about the current process.
7	7		- Gestalt Manager - Allows applications to query the running system configuration. Deprecated after 10.7 (Lion) in favour of the NSProcessInfo class or the SysCtl interface.
8	8		- IOKit framework - A framework that implements non-kernel access to I/O Kit objects (drivers and nubs) through the device-interface mechanism.
9	9
10	10		These are described below with code examples.
11	11
12	12		## Sysctl
13	13
14	14		Sysctl provides an interface that allows you to read and, with appropriate privileges, set many kernel attributes in macOS (and Linux and the BSDs). This provides a wealth of information detailing system hardware and configuration attributes which can be useful when debugging or simply optimising your application (eg to take advantage of threads on multi-core CPU systems).
15	15
16	16		The '/usr/local/share/fpcsrc/rtl/darwin/sysctlh.inc' source file is a partial translation of the macOS '/usr/include/sys/sysctl.h' file. For details of the sysctls available, start a Terminal and type 'man sysctl'. Typing 'sysctl-a \\| more' in a Terminal will list all the sysctls.
17	17
18	18		### FPsysctl()
19	19
20	20		> Note: The function definition below for FPsysctl() is for FPC 3.2.0 and later - For FPC 3.0.4 and earlier the first argument is pchar and not pcint. Adjust the code examples accordingly.
21	21
22	22		The fpSysCtl() function allows you to retrieve system information. The data returned from the function comprises integers (integer and int64), strings (AnsiStrings) and C structures (records). The function is defined in `/usr/local/share/fpcsrc/rtl/bsd/sysctl.pp` as:
23	23
24	24		``` pascal
25	25		function FPsysctl (Name: pcint; namelen:cuint; oldp:pointer;oldlenp:psize_t; newp:pointer;newlen:size_t):cint; cdecl; external name 'sysctl';
26	26		```
27	27
28	28		name -- a pointer to a Management Information Base (MIB) array of integers. Each element of this array must contain the correct value to read or write the particular system attribute.
29	29
30	30		namelen -- the length of the array of integers in name.
31	31
32	32		Note: if the old attribute value is not required, the next two variables can be set to Nil and 0.
33	33
34	34		oldp -- a pointer to the buffer into which the value is copied.
35	35
36	36		oldlenp -- the size of the oldp buffer.
37	37
38	38		Note: if the new attribute value is not being set, the next two variables should be set to Nil and 0.
39	39
40	40		newp -- a pointer to the buffer containing the new value to be set.
41	41
42	42		newlen -- the size of the newp buffer.
43	43
44	44		The size of the MIB array depends on the data to be read or written. The first element indicates the level of the information and the subsequent elements indicate the value to read. The top level names are:
45	45
46		-	~~```~~
	46	+	```text
47	47		--------------------------------------------------------------
48	48		Name Next level names Description
49	49		are found in
50	50		--------------------------------------------------------------
51	51		CTL_DEBUG sys/sysctl.h Debugging
52	52		CTL_VFS sys/mount.h File system
53	53		CTL_HW sys/sysctl.h Generic CPU, I/O
54	54		CTL_KERN sys/sysctl.h High kernel limits
55	55		CTL_MACHDEP sys/sysctl.h Machine dependent
56	56		CTL_NET sys/socket.h Networking
57	57		CTL_USER sys/sysctl.h User-level
58	58		CTL_VM sys/resources.h Virtual memory
59	59		--------------------------------------------------------------
60	60		```
61	61
62	62		Let's look at CTL_HW. The subsequent elements are found in the system sysctl.h file and are:
63	63
64	64		``` pascal
65	65		-------------------------------------------------------------------------------
66	66		Name Value Description
67	67		-------------------------------------------------------------------------------
68	68		#define HW_MACHINE 1 /* string: machine class */
69	69		#define HW_MODEL 2 /* string: specific machine model */
70	70		#define HW_NCPU 3 /* int: number of cpus */
71	71		#define HW_BYTEORDER 4 /* int: machine byte order */
72	72		#define HW_PHYSMEM 5 /* int: total memory */
73	73		#define HW_USERMEM 6 /* int: non-kernel memory */
74	74		#define HW_PAGESIZE 7 /* int: software page size */
75	75		#define HW_DISKNAMES 8 /* strings: disk drive names */
76	76		#define HW_DISKSTATS 9 /* struct: diskstats[] */
77	77		#define HW_EPOCH 10 /* int: 0 for Legacy, else NewWorld */
78	78		#define HW_FLOATINGPT 11 /* int: has HW floating point? */
79	79		#define HW_MACHINE_ARCH 12 /* string: machine architecture */
80	80		#define HW_VECTORUNIT 13 /* int: has HW vector unit? */
81	81		#define HW_BUS_FREQ 14 /* int: Bus Frequency */
82	82		#define HW_CPU_FREQ 15 /* int: CPU Frequency */
83	83		#define HW_CACHELINE 16 /* int: Cache Line Size in Bytes */
84	84		#define HW_L1ICACHESIZE 17 /* int: L1 I Cache Size in Bytes */
85	85		#define HW_L1DCACHESIZE 18 /* int: L1 D Cache Size in Bytes */
86	86		#define HW_L2SETTINGS 19 /* int: L2 Cache Settings */
87	87		#define HW_L2CACHESIZE 20 /* int: L2 Cache Size in Bytes */
88	88		#define HW_L3SETTINGS 21 /* int: L3 Cache Settings */
89	89		#define HW_L3CACHESIZE 22 /* int: L3 Cache Size in Bytes */
90	90		#define HW_TB_FREQ 23 /* int: Bus Frequency */
91	91		#define HW_MEMSIZE 24 /* uint64_t: physical ram size */
92	92		#define HW_AVAILCPU 25 /* int: number of available CPUs */
93	93		#define HW_MAXID 26 /* number of valid hw ids */
94	94		-------------------------------------------------------------------------------
95	95		```
96	96
97	97		Armed with this information, we can now find out the number of CPUs:
98	98
99	99		``` pascal
100	100		// The full source code for this example is available from:
101	101		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/num_cpu.pas
102	102		...
103	103		Uses
104	104		SysUtils, SysCtl, Unix;
105	105		...
106	106		function NumberOfCPU: Integer;
107	107
108	108		var
109	109		mib: array[0..1] of Integer;
110	110		status : Integer;
111	111		len : size_t;
112	112
113	113		begin
114	114		mib[0] := CTL_HW;
115	115		mib[1] := HW_NCPU;
116	116
117	117		len := SizeOf(Result);
118	118		status := fpSysCtl(PCInt(@mib), Length(mib), @Result, @len, Nil, 0);
119	119		if status <> 0 then RaiseLastOSError;
120	120		end;
121	121		```
122	122
123	123		The above code returns the number of CPUs in an integer; you need to check the C header file to determine what is being returned (an integer, int64, string, struct/record).
124	124
125	125		There is a possible issue with the above because if you have, for example, an Intel CPU with hyperthreading. One guess. Yes, it will return the total number of threads and not the number of CPUs or even the number of physical cores. HW_NCPU is pretty much deprecated these days as a useful attribute. Instead, we can retrieve the number of CPU packages, physical CPUs (cores) or logical CPUs (the same as HW_NCPU). To do so requires the use of a second function 'FPsysctlbyname'.
126	126
127	127		However, before we move on, let's look at retrieving a string with FPsysctl() which is a little different than retrieving an integer.
128	128
129	129		``` pascal
130	130		// The full source code for this example is available from:
131	131		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/hardware_model.pas
132	132		...
133	133		Uses
134	134		SysUtils, SysCtl, Unix;
135	135		...
136	136		function HWmodel : AnsiString;
137	137
138	138		var
139	139		mib : array[0..1] of Integer;
140	140		status : Integer;
141	141		len : size_t;
142	142		p : PChar;
143	143
144	144		begin
145	145		mib[0] := CTL_HW;
146	146		mib[1] := HW_MODEL;
147	147
148	148		status := fpSysCtl(PCInt(@mib), Length(mib), Nil, @len, Nil, 0);
149	149		if status <> 0 then RaiseLastOSError;
150	150
151	151		GetMem(p, len);
152	152
153	153		try
154	154		status := fpSysCtl(PCInt(@mib), Length(mib), p, @len, Nil, 0);
155	155		if status <> 0 then RaiseLastOSError;
156	156		Result := p;
157	157		finally
158	158		FreeMem(p);
159	159		end;
160	160		end;
161	161		```
162	162
163	163		Notice that this time we needed two calls to FPsysctl() - one to find out the size of the buffer required to hold the string value, and the second to actually retrieve the string value into that buffer. On my Apple computer this returns the string "Macmini8,1" - the 2018 Mac mini.
164	164
165	165		No, we're not quite ready to move on yet... we still need to see how to retrieve information in a C structure (Pascal record).
166	166
167	167		``` pascal
168	168		// The full source code for this example is available from:
169	169		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/swap_usage.pas
170	170		...
171	171		Uses
172	172		SysUtils, SysCtl, Unix;
173	173		...
174	174		function SwapUsage: String;
175	175
176	176		type
177	177		swapinfo = record
178	178		xsu_total : Int64;
179	179		xsu_avail : Int64;
180	180		xsu_used : Int64;
181	181		xsu_pagesize : Integer;
182	182		xsu_encrypted: Boolean;
183	183		end;
184	184
185	185		const
186	186		VM_SWAPUSAGE = 5;
187	187
188	188		var
189	189		mib : array[0..1] of Integer;
190	190		status : Integer;
191	191		len : size_t;
192	192		swap : swapinfo;
193	193		SwapEncrypted: String;
194	194
195	195		begin
196	196		mib[0] := CTL_VM;
197	197		mib[1] := VM_SWAPUSAGE;
198	198		swap := Default(swapinfo);
199	199
200	200		FillChar(swap, sizeof(swap), 0);
201	201		len := sizeof(swap);
202	202
203	203		status := fpSysCtl(PCInt(@mib), Length(mib), @swap, @len, Nil, 0);
204	204		if status <> 0 then RaiseLastOSError;
205	205
206	206		if(swap.xsu_encrypted = true) then
207	207		SwapEncrypted := 'Yes' else SwapEncrypted := 'No';
208	208
209	209		Result := 'Swap total: ' + FloatToStr(Round(swap.xsu_total /1024 /1024)) + ' MB'
210	210		+ LineEnding + 'Swap used: ' + FloatToStr(Round(swap.xsu_used /1024 /1024)) + ' MB'
211	211		+ LineEnding + 'Swap free: ' + FloatToStr(Round(swap.xsu_avail /1024 /1024)) + ' MB'
212	212		+ LineEnding + 'Swap page size: ' + IntToStr(swap.xsu_pagesize) + ' bytes'
213	213		+ LineEnding + 'Swap encrypted: ' + SwapEncrypted + LineEnding;
214	214		end;
215	215		```
216	216
217	217		> Note: If your computer has not used any swap, then the results for Swap total, used and free will all be zero.
218	218
219	219		On my computer this returned:
220	220
221		-	~~```~~
	221	+	```text
222	222		Swap total: 1024 MB
223	223		Swap used: 191 MB
224	224		Swap free: 833 MB
225	225		Swap page size: 4096 bytes
226	226		Swap encrypted: Yes
227	227		```
228	228
229	229		The swapinfo record was pretty easily translated from the C structure found in the system `sysctl.h` file:
230	230
231	231		``` c
232	232		struct xsw_usage {
233	233		u_int64_t xsu_total;
234	234		u_int64_t xsu_avail;
235	235		u_int64_t xsu_used;
236	236		u_int32_t xsu_pagesize;
237	237		boolean_t xsu_encrypted;
238	238		};
239	239		```
240	240
241	241		We also defined the MIB constant VM_SWAPUSAGE by looking at the system `sysctl.h` file. Why? Because Free Pascal 3.2.0 and earlier are missing this identifier (fixed in FPC 3.2.2). So, we looked it up and found:
242	242
243	243		``` c
244	244		#define VM_SWAPUSAGE 5 /* total swap usage */
245	245		```
246	246
247	247		Finally, yes, it is time to move on to the FPsysctlbyname() function.
248	248
249	249		### FPsysctlbyname
250	250
251	251		The FPsysctlbyname function is defined in '/usr/local/share/fpcsrc/rtl/bsd/sysctl.pp' as:
252	252
253	253		``` pascal
254	254		function FPsysctlbyname (Name: pchar; oldp:pointer;oldlenp:psize_t; newp:pointer;newlen:size_t):cint; cdecl; external name 'sysctlbyname';
255	255		```
256	256
257	257		There. Not really very different from the FPsysctl() function. Is that a sigh of relief? So let's look at finally retrieving the number of physical CPU cores.
258	258
259	259		``` pascal
260	260		// Full source code for this example is available from:
261	261		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/num_cores.pas
262	262		...
263	263		{$mode objfpc}
264	264		...
265	265
266	266		Uses
267	267		SysCtl, SysUtils, Unix;
268	268
269	269		function NumberOfCores: Integer;
270	270
271	271		var
272	272		status : Integer;
273	273		len : size_t;
274	274
275	275		begin
276	276		len := SizeOf(Result);
277	277
278	278		status := fpSysCtlByName('hw.physicalcpu', @Result, @len, Nil, 0);
279	279		if status <> 0 then RaiseLastOSError;
280	280		end;
281	281		```
282	282
283	283		On my 2018 Mac mini this returns the correct number of cores: 6. Where do you find the special incantation hw.physicalcpu ? Yes, in the system `sysctl.h` file. Here's a brief excerpt of some of the hardware selectors:
284	284
285	285		``` pascal
286	286		These are the support HW selectors for sysctlbyname. Parameters that are byte counts or frequencies are 64 bit numbers.
287	287		All other parameters are 32 bit numbers.
288	288
289	289		hw.memsize - The number of bytes of physical memory in the system.
290	290		hw.ncpu - The maximum number of processors that could be available this boot.
291	291		Use this value for sizing of static per processor arrays; i.e. processor load statistics.
292	292		hw.activecpu - The number of processors currently available for executing threads.
293	293		Use this number to determine the number threads to create in SMP aware applications.
294	294		This number can change when power management modes are changed.
295	295		hw.physicalcpu - The number of physical processors available in the current power management mode.
296	296		hw.physicalcpu_max - The maximum number of physical processors that could be available this boot
297	297		hw.logicalcpu - The number of logical processors available in the current power management mode.
298	298		hw.logicalcpu_max - The maximum number of logical processors that could be available this boot
299	299		hw.tbfrequency - This gives the time base frequency used by the OS and is the basis of all timing services.
300	300		In general is is better to use mach's or higher level timing services, but this value
301	301		is needed to convert the PPC Time Base registers to real time.
302	302		hw.cpufrequency - These values provide the current, min and max cpu frequency. The min and max are for
303	303		hw.cpufrequency_max - all power management modes. The current frequency is the max frequency in the current mode.
304	304		hw.cpufrequency_min - All frequencies are in Hz.
305	305		hw.busfrequency - These values provide the current, min and max bus frequency. The min and max are for
306	306		hw.busfrequency_max - all power management modes. The current frequency is the max frequency in the current mode.
307	307		hw.busfrequency_min - All frequencies are in Hz.
308	308		hw.cputype - These values provide the mach-o cpu type and subtype. A complete list is in <mach/machine.h>
309	309		hw.cpusubtype - These values should be used to determine what processor family the running cpu is from so that
310	310		the best binary can be chosen, or the best dynamic code generated. They should not be used
311	311		to determine if a given processor feature is available.
312	312		hw.cputhreadtype - This value will be present if the processor supports threads. Like hw.cpusubtype this selector
313	313		should not be used to infer features, and only used to name the processors thread architecture.
314	314		The values are defined in <mach/machine.h>
315	315		hw.byteorder - Gives the byte order of the processor. 4321 for big endian, 1234 for little.
316	316		hw.pagesize - Gives the size in bytes of the pages used by the processor and VM system.
317	317		hw.cachelinesize - Gives the size in bytes of the processor's cache lines.
318	318		This value should be use to control the strides of loops that use cache control instructions
319	319		like dcbz, dcbt or dcbst.
320	320		hw.l1dcachesize - These values provide the size in bytes of the L1, L2 and L3 caches. If a cache is not present
321	321		hw.l1icachesize - then the selector will return an error.
322	322		hw.l2cachesize -
323	323		hw.l3cachesize -
324	324		hw.packages - Gives the number of processor packages.
325	325		```
326	326
327	327		If you prefer, you can instead use the `sysctl` command line utility in a Terminal to list all the hw selectors with the `sysctl hw` command.
328	328
329	329		Retrieving a string value, rather than an integer, is again reminiscent of FPsysctl(). Two calls to FPsysctlbyname() are needed: (1) to find out the size of the buffer to hold the string to be returned and (2) to return the string value into that buffer. Don't forget to allocate memory for the buffer before the second call!
330	330
331	331		``` pascal
332	332		// Full source code for this example is available from:
333	333		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/brand_cpu.pas
334	334		...
335	335		{$mode objfpc}
336	336		...
337	337
338	338		Uses
339	339		SysCtl, SysUtils, Unix;
340	340
341	341		function BrandOfCPU: AnsiString;
342	342
343	343		var
344	344		status : Integer;
345	345		len : size_t;
346	346		p : PChar;
347	347
348	348		begin
349	349		status := fpSysCtlByName('machdep.cpu.brand_string', Nil, @len, Nil, 0);
350	350		if status <> 0 then RaiseLastOSError;
351	351
352	352		GetMem(p, len);
353	353
354	354		try
355	355		status := fpSysCtlByName('machdep.cpu.brand_string', p, @len, Nil, 0);
356	356		if status <> 0 then RaiseLastOSError;
357	357		Result := p;
358	358		finally
359	359		FreeMem(p);
360	360		end;
361	361		end;
362	362		```
363	363
364	364		On my 2018 Mac mini computer, this returns the very informative string: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz. On my 2020 Mac mini computer, this returns the somewhat less informative string: Apple M1.
365	365
366	366		Oh, you noticed, I changed the top level identifier from hw to machdep (machine dependent). Again, consult `sysctl.h` or use the `sysctl` command line utility in a Terminal.
367	367
368	368		``` pascal
369	369		// Full source code for this example is available from:
370	370		// https://sourceforge.net/p/lazarus-wiki-projects/code/ci/master/tree/fpc_sysctls/os_version.pas
371	371
372	372		// Note: The kern.osproductversion attribute was added to the Darwin kernel in December 2018
373	373		// https://github.com/apple/darwin-xnu/commit/5bbb823c13f3ab1ab58878f96b35433a29882676
374	374
375	375		Program os_version;
376	376
377	377		{$mode objfpc}
378	378
379	379		Uses
380	380		SysCtl, SysUtils, Unix;
381	381
382	382		function OS_version : AnsiString;
383	383
384	384		var
385	385		status : Integer;
386	386		len : size_t;
387	387		p : PChar;
388	388
389	389		begin
390	390		status := fpSysCtlByName('kern.osproductversion', Nil, @len, Nil, 0);
391	391		if status <> 0 then RaiseLastOSError;
392	392
393	393		GetMem(p, len);
394	394
395	395		try
396	396		status := fpSysCtlByName('kern.osproductversion', p, @len, Nil, 0);
397	397		if status <> 0 then RaiseLastOSError;
398	398		Result := p;
399	399		finally
400	400		FreeMem(p);
401	401		end;
402	402		end;
403	403
404	404		begin
405	405		WriteLn(OS_version);
406	406		end.
407	407		```
408	408
409	409		The above FPC example program will return the operating system version. On my M1 processor Mac mini this was "11.2.3" (Big Sur).
410	410
411	411		### Last words
412	412
413	413		For the optimised, performance fiends out there, the man page for these functions notes that the FPsysctl() function runs in about a third the time as the same request made via the FPsysctlbyname() function.
414	414
415	415		It should be noted that many of the sysctl attributes are read-only, but there are also quite a few that can be changed. I've left changing a sysctl attribute as an exercise for you dear reader. It should be simple if you study the definitions of the function parameters, paying particular attention to newp and newlen.
416	416
417	417		## NSProcessinfo
418	418
419	419		Each macOS process has a single, shared NSProcessInfo object, known as a process information agent. This process information agent can return information such as arguments, environment variables, host name, and process name. The processInfo class method returns the shared agent for the current process—that is, the process whose object sent the message.
420	420
421	421		### Properties
422	422
423	423		\| Property \| Description \|
424	424		\|----\|----\|
425	425		\| processInfo \| Returns the process information agent for the process. An NSProcessInfo object is created the first time this method is invoked, and that same object is returned on each subsequent invocation. \|
426	426		\| arguments \| Array of strings with the command-line arguments for the process. \|
427	427		\| environment \| The variable names (keys) and their values in the environment from which the process was launched. \|
428	428		\| globallyUniqueString \| Global unique identifier for the process. The global ID for the process includes the host name, process ID, and a time stamp, which ensures that the ID is unique for the network. This property generates a new string each time its getter is invoked, and it uses a counter to guarantee that strings created from the same process are unique. \|
429	429		\| processIdentifier \| The identifier of the process (often called process ID or PID). \|
430	430		\| processName \| The name of the process. \|
431	431		\| userName \| Returns the account name of the current user. macOS 10.12+ \|
432	432		\| fullUserName \| Returns the full name of the current user. macOS 10.12+ \|
433	433		\| hostName \| The name of the host computer on which the process is executing. \|
434	434		\| operatingSystemVersionString \| A string containing the version of the operating system on which the process is executing. macOS 10.2+ \|
435	435		\| operatingSystemVersion \| The version of the operating system on which the process is executing. macOS 10.10+ \|
436	436		\| processorCount \| The number of processing cores available on the computer. Equivalent to: `sysctl -n hw.ncpu`. macOS 10.5+ \|
437	437		\| activeProcessorCount \| The number of active processing cores available on the computer. Equivalent to: `sysctl -n hw.logicalcpu`. macOS 10.5+ \|
438	438		\| physicalMemory \| The amount of physical memory on the computer in bytes. macOS 10.5+ \|
439	439		\| systemUptime \| The amount of time in seconds that the system has been awake since the last time it was restarted. macOS 10.6+ \|
440	440		\| thermalState \| The current thermal state of the system: Nominal, Fair, Serious or Critical. macOS 10.10.3+ \|
441	441		\| automaticTerminationSupportEnabled \| A Boolean value indicating whether the app supports automatic termination. Currently, setting this property to False has no effect. macOS 10.7+ \|
442	442		\| \| \|
443	443
444	444		### Methods
445	445
446	446		\| Method \| Description \|
447	447		\|----\|----\|
448	448		\| isOperatingSystemAtLeastVersion \| Returns a Boolean value indicating whether the version of the operating system on which the process is executing is the same or later than the given version. macOS 10.10+ \|
449	449
450	450		### Example code
451	451
452	452		``` pascal
453	453		unit Unit1;
454	454
455	455		{$mode objfpc}{$H+}
456	456		{$modeswitch objectivec1}
457	457
458	458		interface
459	459
460	460		uses
461	461		Classes, SysUtils, Forms, Dialogs, StdCtrls,
462	462		ctypes, // needed for cint
463	463		typinfo, // needed for GetEnumName
464	464		CocoaAll; // needed for NS...
465	465
466	466		type
467	467		// From HERE...
468	468		NSProcessInfoThermalState = (
469	469		Nominal, // within the normal range; no corrective action is required.
470	470		Fair, // thermal state is slightly elevated and the fan is audible.
471	471		Serious, // fan is at maximum speed; performance may be affected;
472	472		// applications should reduce use of CPU, GPU, and any I/O.
473	473		Critical); // thermal state severely affects performance; need immediate cooling;
474	474		// applications should reduce use of CPU, GPU, and any I/O to minimum
475	475		// required for user interaction; stop using peripherals such as cameras.
476	476
477	477		NSOperatingSystemVersion = record
478	478		majorVersion: NSInteger;
479	479		minorVersion: NSInteger;
480	480		patchVersion: NSInteger;
481	481		end;
482	482
483	483		NSProcessInfo = objcclass external (NSObject)
484	484		private
485	485		environment_: NSDictionary;
486	486		arguments_: NSArray;
487	487		hostName_: NSString;
488	488		name: NSString;
489	489		automaticTerminationOptOutCounter: NSInteger;
490	490		public
491	491		class function processInfo: NSProcessInfo; message 'processInfo';
492	492		function environment: NSDictionary; message 'environment';
493	493		function arguments: NSArray; message 'arguments';
494	494		function hostName: NSString; message 'hostName';
495	495		procedure setProcessName(newValue: NSString); message 'setProcessName:';
496	496		function processName: NSString; message 'processName';
497	497		function processIdentifier: cint; message 'processIdentifier';
498	498		function globallyUniqueString: NSString; message 'globallyUniqueString';
499	499		function operatingSystemVersionString: NSString; message 'operatingSystemVersionString';
500	500		function userName: NSString; message 'userName';
501	501		function fullUserName: NSString; message 'fullUserName';
502	502		function operatingSystemVersion: NSOperatingSystemVersion; message 'operatingSystemVersion';
503	503		function processorCount: NSUInteger; message 'processorCount';
504	504		function activeProcessorCount: NSUInteger; message 'activeProcessorCount';
505	505		function physicalMemory: culonglong; message 'physicalMemory';
506	506		function isOperatingSystemAtLeastVersion (os_version: NSOperatingSystemVersion): Boolean; message 'isOperatingSystemAtLeastVersion:';
507	507		function systemUptime: NSTimeInterval; message 'systemUptime';
508	508		function thermalState: NSInteger; message 'thermalState';
509	509		{procedure disableSuddenTermination; message 'disableSuddenTermination';
510	510		procedure enableSuddenTermination; message 'enableSuddenTermination';
511	511		procedure disableAutomaticTermination (reason: NSString); message 'disableAutomaticTermination:';
512	512		procedure enableAutomaticTermination (reason: NSString); message 'enableAutomaticTermination:';}
513	513		procedure setAutomaticTerminationSupportEnabled(newValue: Boolean); message 'setAutomaticTerminationSupportEnabled:';
514	514		function automaticTerminationSupportEnabled: Boolean; message 'automaticTerminationSupportEnabled';
515	515		end;
516	516		// ... To HERE is ONLY NEEDED if you are using FPC 3.0.4 or earlier. FPC 3.2.0 does not need this section.
517	517
518	518		{ TForm1 }
519	519
520	520		TForm1 = Class(TForm)
521	521		Button1: TButton;
522	522		Memo1: TMemo;
523	523		procedure Button1Click(Sender: TObject);
524	524		private
525	525
526	526		public
527	527
528	528		end;
529	529
530	530		var
531	531		Form1: TForm1;
532	532
533	533		implementation
534	534
535	535		{$R *.lfm}
536	536
537	537		{ TForm1 }
538	538
539	539		procedure ProcessInfo;
540	540		var
541	541		thermalState : String;
542	542		myDictionary : NSDictionary;
543	543		i : Byte = 0;
544	544		minOsVer : NSOperatingSystemVersion;
545	545		begin
546	546		Form1.Memo1.Lines.Clear;
547	547
548	548		Form1.Memo1.Lines.Add('Processor count: '
549	549		+ IntToStr(NSProcessInfo.ProcessInfo.processorCount)
550	550		+ LineEnding + 'Active processors: '
551	551		+ IntToStr(NSProcessInfo.ProcessInfo.activeProcessorCount)
552	552		+ LineEnding + 'Physical memory: '
553	553		+ FloatToStr(NSProcessInfo.ProcessInfo.physicalMemory / 1024 / 1024 / 1024) + 'GB'
554	554		+ LinEending + 'Process name: '
555	555		+ NSProcessInfo.ProcessInfo.processName.UTF8String
556	556		+ LinEending + 'PID: '
557	557		+ IntToStr(NSProcessInfo.ProcessInfo.processIdentifier)
558	558		+ LineEnding + 'Uptime: '
559	559		+ FormatFloat('0.00', NSProcessInfo.ProcessInfo.systemUptime / 60 / 60 / 24) + ' days'
560	560		+ LineEnding + 'Operating system: '
561	561		+ NSProcessInfo.ProcessInfo.operatingSystemVersionString.UTF8String
562	562		+ LineEnding
563	563		+ 'Major: ' + IntToStr(NSProcessInfo.ProcessInfo.OperatingSystemVersion.majorVersion)
564	564		+ ' Minor: ' + IntToStr(NSProcessInfo.ProcessInfo.OperatingSystemVersion.minorVersion)
565	565		+ ' Patch: ' + IntToStr(NSProcessInfo.ProcessInfo.OperatingSystemVersion.patchVersion)
566	566		+ LineEnding + 'Hostname: '
567	567		+ NSProcessInfo.ProcessInfo.hostName.UTF8String
568	568		+ LineEnding + 'Globally unique string: '
569	569		+ NSProcessInfo.ProcessInfo.globallyUniqueString.UTF8String
570	570		+ LineEnding + 'Username: '
571	571		+ NSProcessInfo.ProcessInfo.userName.UTF8String
572	572		+ LineEnding + 'Full Username: '
573	573		+ NSProcessInfo.ProcessInfo.fullUserName.UTF8String
574	574		+ LineEnding
575	575		);
576	576
577	577		myDictionary := NSProcessInfo.ProcessInfo.environment;
578	578		for i := 0 to (myDictionary.count - 1) do
579	579		begin
580	580		Form1.Memo1.Lines.Add('Env Var: '
581	581		+ myDictionary.allKeys.objectAtIndex(i).UTF8String
582	582		+ ' = '
583	583		+ myDictionary.allValues.objectAtIndex(i).UTF8String
584	584		);
585	585		end;
586	586
587	587		ThermalState := GetEnumName(TypeInfo(NSProcessInfoThermalState), Ord(NSProcessInfo.ProcessInfo.thermalState));
588	588		Form1.Memo1.Lines.Add(LineEnding + 'Thermal state: ' + ThermalState
589	589		);
590	590
591	591		// Setup minimum OS version
592	592		minOsVer.majorVersion:= 10;
593	593		minOsVer.minorVersion:= 14;
594	594		minOsVer.patchVersion:= 6;
595	595
596	596		if(NSProcessInfo.ProcessInfo.isOperatingSystemAtLeastVersion(minOSVer)) then
597	597		Form1.Memo1.Lines.Add(LineEnding + 'OS version is at least 10.14.6' + LineEnding)
598	598		else
599	599		Form1.Memo1.Lines.Add(LineEnding + 'OS version is NOT at least 10.14.6' + LineEnding)
600	600		end;
601	601
602	602		procedure TForm1.Button1Click(Sender: TObject);
603	603		begin
604	604		processInfo;
605	605		end;
606	606
607	607		end.
608	608		```
609	609
610	610		## Gestalt Manager
611	611
612	612		Despite Apple's deprecation of the Gestalt Manager in favour of the NSProcessInfo class or the SysCtl Interface, there are still occasions when you will need to use it. For example, the NSProcessInfo instance property `OperatingSystemVersion` is only available from macOS 10.10 (Yosemite) onwards according to Apple's documentation, although it seems to also work in macOS 10.9 (Mavericks).
613	613
614	614		So what do you do if you want to check the version of the operating system across all versions back to Mac OS X 10.0 (Cheetah)? The example code below holds the solution.
615	615
616	616		### Example: Retrieving OS version from Mac OS X 10.0+
617	617
618	618		``` pascal
619	619		unit Unit1;
620	620
621	621		{$mode objfpc}{$H+}
622	622		{$modeswitch objectivec2}
623	623
624	624		interface
625	625
626	626		uses
627	627		Classes, SysUtils, Forms, Dialogs, StdCtrls, ExtCtrls,
628	628		MacOSAll,
629	629		CocoaAll;
630	630
631	631		type
632	632
633	633		{ TForm1 }
634	634
635	635		TForm1 = Class(TForm)
636	636		Memo1: TMemo;
637	637		Button1: TButton;
638	638		procedure Button1Click(Sender: TObject);
639	639		private
640	640		public
641	641
642	642		end;
643	643
644	644		var
645	645		Form1: TForm1;
646	646		counter: Int64;
647	647
648	648		implementation
649	649
650	650		{$R *.lfm}
651	651
652	652		{ TForm1 }
653	653
654	654		procedure ProcessInfo;
655	655		begin
656	656		Form1.Memo1.Lines.Clear;
657	657
658	658		Form1.Memo1.Lines.Add('macOS version: '
659	659		+ IntToStr(NSProcessInfo.ProcessInfo.operatingSystemVersion.majorVersion)
660	660		+ '.'
661	661		+ IntToStr(NSProcessInfo.ProcessInfo.operatingSystemVersion.minorVersion)
662	662		+ '.'
663	663		+ IntToStr(NSProcessInfo.ProcessInfo.operatingSystemVersion.patchVersion)
664	664		);
665	665		end;
666	666
667	667		Procedure GestaltInfo;
668	668		var
669	669		majorVersion: LongInt = 0;
670	670		minorVersion: LongInt = 0;
671	671		patchVersion: LongInt = 0;
672	672		begin
673	673		Form1.Memo1.Lines.Clear;
674	674		Form1.Memo1.Lines.Add('Trying another way...');
675	675
676	676		Gestalt(gestaltSystemVersionMajor, majorVersion);
677	677		Gestalt(gestaltSystemVersionMinor, minorVersion);
678	678		Gestalt(gestaltSystemVersionBugFix, patchVersion);
679	679
680	680		Form1.Memo1.Lines.Add('macOS version: ' + IntToStr(majorVersion) + '.' +
681	681		IntToStr(minorVersion) + '.' + IntToStr(patchVersion));
682	682		end;
683	683
684	684		procedure TForm1.Button1Click(Sender: TObject);
685	685		var
686	686		aSEL : SEL;
687	687		begin
688	688		// Check whether OS version responds to this selector
689	689		aSEL := objcselector('operatingSystemVersion');
690	690		if NSProcessInfo.processInfo.respondsToSelector(aSEL) then
691	691		ProcessInfo
692	692		// Otherwise fallback to the deprecated Gestalt Manager
693	693		else
694	694		GestaltInfo;
695	695		end;
696	696
697	697		end.
698	698		```
699	699
700	700		## IOKit
701	701
702	702		IOKit is Apple’s object-oriented framework for developing device drivers for macOS. While the main use of the IOKit framework is for developers creating device drivers that are to be resident in the kernel, it is also of use to application developers who can using an IOKit device interface to communicate with the Apple hardware.
703	703
704	704		While the focus of this section is on accessing macOS system information, it should be noted that the IOKit framework has been deprecated by Apple in macOS 10.15 Catalina in favour of the DriverKit framework which debuted in that version of macOS. DriverKit provides a fully modernized replacement for IOKit to create device drivers. System extensions and drivers built with DriverKit run in user space, where they can't compromise the security or stability of macOS.
705	705
706	706		### Example: Retrieving the platform serial number
707	707
708	708		``` pascal
709	709		program project1;
710	710
711	711		{$mode objfpc}{$H+}
712	712		{$modeswitch cvar}
713	713		{$linkframework IOKit}
714	714
715	715		uses
716	716		ctypes, Classes, MacOSAll;
717	717		{ you can add units after this };
718	718
719	719		type
720	720		kern_return_t = cint; // if you use "integer" then you don't need "ctypes" unit
721	721		io_object_t = mach_port_t;
722	722		io_registry_entry_t = io_object_t;
723	723
724	724		io_string_t = array [0..511] of ansichar;
725	725		IOOptionBits = UInt32;
726	726
727	727		const
728	728		kIOPlatformSerialNumber = 'IOPlatformSerialNumber';
729	729
730	730		var
731	731		kIOMasterPortDefault:mach_port_t; cvar; external;
732	732
733	733		function IORegistryEntryFromPath( masterPort: mach_port_t; const path: io_string_t): io_registry_entry_t; cdecl; external;
734	734		function IORegistryEntryCreateCFProperty(entry: io_registry_entry_t; key: CFStringRef; allocator:CFAllocatorRef; options: IOOptionBits): CFTypeRef; cdecl; external;
735	735		function IOObjectRelease(entry: io_registry_entry_t): kern_return_t; cdecl; external;
736	736
737	737		function get_platform_serial_num: string;
738	738		var
739	739		ioRegistryRoot :io_registry_entry_t;
740	740		serialnumCf :CFStringRef;
741	741		l :integer;
742	742		begin
743	743		ioRegistryRoot := IORegistryEntryFromPath(kIOMasterPortDefault, 'IOService:/');
744	744		serialnumCf := CFStringRef (IORegistryEntryCreateCFProperty(ioRegistryRoot, CFSTR(kIOPlatformSerialNumber), kCFAllocatorDefault, 0));
745	745		IOObjectRelease(ioRegistryRoot);
746	746		SetLength(Result, 32);
747	747		CFStringGetCString(serialnumCf, @Result[1], length(Result), kCFStringEncodingMacRoman);
748	748		CFRelease(serialnumCf);
749	749		l:=StrLen(@Result[1]);
750	750		SetLength(Result, l);
751	751		end;
752	752
753	753		begin
754	754		WriteLn('Platform serial number: ', get_platform_serial_num);
755	755		end.
756	756		```
757	757
758	758		### Example: Retrieving the platform UUID
759	759
760	760		A UUID (Universally Unique Identifier) is a 16-byte long number. It is normally expressed in a standard format of characters representing hexadecimal digits. UUIDs were formerly known as Globally Unique Identifiers (GUIDs), but are now officially Universally Unique Identifiers, or UUIDs, and are governed by Open Software Foundation, ISO/IEC, and IETF standards.
761	761
762	762		``` pascal
763	763		program project1;
764	764
765	765		{$mode objfpc}{$H+}
766	766		{$modeswitch cvar}
767	767		{$linkframework IOKit}
768	768
769	769		uses
770	770		ctypes, Classes, MacOSAll
771	771		{ you can add units after this };
772	772
773	773		type
774	774		kern_return_t = cint; // if you use "integer" then you don't need "ctypes" unit
775	775		io_object_t = mach_port_t;
776	776		io_registry_entry_t = io_object_t;
777	777
778	778		io_string_t = array [0..511] of ansichar;
779	779		IOOptionBits = UInt32;
780	780
781	781		const
782	782		kIOPlatformUUIDKey = 'IOPlatformUUID';
783	783
784	784		var
785	785		kIOMasterPortDefault:mach_port_t; cvar; external;
786	786
787	787		function IORegistryEntryFromPath( masterPort: mach_port_t; const path: io_string_t): io_registry_entry_t; cdecl; external;
788	788		function IORegistryEntryCreateCFProperty(entry: io_registry_entry_t; key: CFStringRef; allocator:CFAllocatorRef; options: IOOptionBits): CFTypeRef; cdecl; external;
789	789		function IOObjectRelease(entry: io_registry_entry_t): kern_return_t; cdecl; external;
790	790
791	791		function get_platform_uuid: string;
792	792		var
793	793		ioRegistryRoot :io_registry_entry_t;
794	794		uuidCf :CFStringRef;
795	795		l :integer;
796	796		begin
797	797		ioRegistryRoot := IORegistryEntryFromPath(kIOMasterPortDefault, 'IOService:/');
798	798		uuidCf := CFStringRef (IORegistryEntryCreateCFProperty(ioRegistryRoot, CFSTR(kIOPlatformUUIDKey), kCFAllocatorDefault, 0));
799	799		IOObjectRelease(ioRegistryRoot);
800	800		SetLength(Result, 1024);
801	801		CFStringGetCString(uuidCf, @Result[1], length(Result), kCFStringEncodingMacRoman);
802	802		CFRelease(uuidCf);
803	803		l:=StrLen(@Result[1]);
804	804		SetLength(Result, l);
805	805		end;
806	806
807	807		begin
808	808		WriteLn('Platform UUID: ', get_platform_uuid);
809	809		end.
810	810		```
811	811
812	812		## External links
813	813
814	814		- [Apple: SysCtl](https://developer.apple.com/documentation/installerjs/system/1812308-sysctl)
815	815		- [Apple: NSProcessinfo](https://developer.apple.com/documentation/foundation/nsprocessinfo)
816	816		- [Apple: Gestalt Manager](https://developer.apple.com/documentation/coreservices/carbon_core/gestalt_manager)
817	817		- [Apple: Introduction to I/O Kit Fundamentals](https://developer.apple.com/library/archive/documentation/DeviceDrivers/Conceptual/IOKitFundamentals/Introduction/Introduction.html)
818	818		- [Apple: IOKit framework](https://developer.apple.com/documentation/iokit)
819	819		- [Apple: DriverKit framework](https://developer.apple.com/documentation/driverkit)
820	820		- [Apple: Uniquely Identifying a Macintosh Computer](https://developer.apple.com/library/archive/technotes/tn1103/_index.html#//apple_ref/doc/uid/DTS10002943)
821	821
822	822		---
823	823		From the Free Pascal wiki, page "Accessing macOS System Information", as it stood on 2022-01-05 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history