1 #include <unistd.h>
2 #include <stdint.h>
3 #include <sys/time.h>
4 #include <System/sys/codesign.h>
5 #include <mach/mach_time.h>
6 #include <mach/mach.h>
7 #include <darwintest.h>
8 #include <stdlib.h>
9
10 T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));
11
12 #if !defined(CS_OPS_CLEARPLATFORM)
13 #define CS_OPS_CLEARPLATFORM 13
14 #endif
15
16 #define WINDOW 1 /* seconds */
17 #define MAX_ATTEMP_PER_SEC 10
18 #define ITER 30
19 #define RETRY 5
20
21 static int
remove_platform_binary(void)22 remove_platform_binary(void)
23 {
24 int ret;
25 uint32_t my_csflags;
26
27 T_QUIET; T_ASSERT_POSIX_ZERO(csops(getpid(), CS_OPS_STATUS, &my_csflags, sizeof(my_csflags)), NULL);
28
29 if (!(my_csflags & CS_PLATFORM_BINARY)) {
30 return 0;
31 }
32
33 ret = csops(getpid(), CS_OPS_CLEARPLATFORM, NULL, 0);
34 if (ret) {
35 switch (errno) {
36 case ENOTSUP:
37 T_LOG("clearing platform binary not supported, skipping test");
38 return -1;
39 default:
40 T_LOG("csops failed with flag CS_OPS_CLEARPLATFORM");
41 return -1;
42 }
43 }
44
45 my_csflags = 0;
46 T_QUIET; T_ASSERT_POSIX_ZERO(csops(getpid(), CS_OPS_STATUS, &my_csflags, sizeof(my_csflags)), NULL);
47
48 if (my_csflags & CS_PLATFORM_BINARY) {
49 T_LOG("platform binary flag still set");
50 return -1;
51 }
52
53 return 0;
54 }
55
56 struct all_host_info {
57 vm_statistics64_data_t host_vm_info64_rev0;
58 vm_statistics64_data_t host_vm_info64_rev1;
59 vm_extmod_statistics_data_t host_extmod_info64;
60 host_load_info_data_t host_load_info;
61 vm_statistics_data_t host_vm_info_rev0;
62 vm_statistics_data_t host_vm_info_rev1;
63 vm_statistics_data_t host_vm_info_rev2;
64 host_cpu_load_info_data_t host_cpu_load_info;
65 task_power_info_v2_data_t host_expired_task_info;
66 task_power_info_v2_data_t host_expired_task_info2;
67 };
68
69 static void
check_host_info(struct all_host_info * data,unsigned long iter,char lett)70 check_host_info(struct all_host_info* data, unsigned long iter, char lett)
71 {
72 char* datap;
73 unsigned long i, j;
74
75 /* check that for the shorter revisions no data is copied on the bytes of diff with the longer */
76 for (j = 0; j < iter; j++) {
77 datap = (char*) &data[j].host_vm_info64_rev0;
78 for (i = (HOST_VM_INFO64_REV0_COUNT * sizeof(int)); i < (HOST_VM_INFO64_REV1_COUNT * sizeof(int)); i++) {
79 T_QUIET; T_ASSERT_EQ(datap[i], lett, "HOST_VM_INFO64_REV0 byte %lu iter %lu", i, j);
80 }
81
82 datap = (char*) &data[j].host_vm_info_rev0;
83 for (i = (HOST_VM_INFO_REV0_COUNT * sizeof(int)); i < (HOST_VM_INFO_REV2_COUNT * sizeof(int)); i++) {
84 T_QUIET; T_ASSERT_EQ(datap[i], lett, "HOST_VM_INFO_REV0 byte %lu iter %lu", i, j);
85 }
86
87 datap = (char*) &data[j].host_vm_info_rev1;
88 for (i = (HOST_VM_INFO_REV1_COUNT * sizeof(int)); i < (HOST_VM_INFO_REV2_COUNT * sizeof(int)); i++) {
89 T_QUIET; T_ASSERT_EQ(datap[i], lett, "HOST_VM_INFO_REV1 byte %lu iter %lu", i, j);
90 }
91
92 datap = (char*) &data[j].host_expired_task_info;
93 for (i = (TASK_POWER_INFO_COUNT * sizeof(int)); i < (TASK_POWER_INFO_V2_COUNT * sizeof(int)); i++) {
94 T_QUIET; T_ASSERT_EQ(datap[i], lett, "TASK_POWER_INFO_COUNT byte %lu iter %lu", i, j);
95 }
96 }
97 T_LOG("No data overflow");
98
99 datap = (char*) data;
100
101 /* check that after MAX_ATTEMP_PER_SEC data are all the same */
102 for (i = 0; i < sizeof(struct all_host_info); i++) {
103 for (j = MAX_ATTEMP_PER_SEC - 1; j < iter - 1; j++) {
104 T_QUIET; T_ASSERT_EQ(datap[i + (j * sizeof(struct all_host_info))], datap[i + ((j + 1) * sizeof(struct all_host_info))], "all_host_info iter %lu does not match iter %lu", j, j + 1);
105 }
106 }
107
108 T_LOG("Data was cached");
109 }
110
111 static void
get_host_info(struct all_host_info * data,host_t self,int iter)112 get_host_info(struct all_host_info* data, host_t self, int iter)
113 {
114 int i;
115 unsigned int count;
116 for (i = 0; i < iter; i++) {
117 count = HOST_VM_INFO64_REV0_COUNT;
118 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics64(self, HOST_VM_INFO64, (host_info64_t)&data[i].host_vm_info64_rev0, &count), NULL);
119 count = HOST_VM_INFO64_REV1_COUNT;
120 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics64(self, HOST_VM_INFO64, (host_info64_t)&data[i].host_vm_info64_rev1, &count), NULL);
121 count = HOST_EXTMOD_INFO64_COUNT;
122 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics64(self, HOST_EXTMOD_INFO64, (host_info64_t)&data[i].host_extmod_info64, &count), NULL);
123 count = HOST_LOAD_INFO_COUNT;
124 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_LOAD_INFO, (host_info_t)&data[i].host_load_info, &count), NULL);
125 count = HOST_VM_INFO_REV0_COUNT;
126 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_VM_INFO, (host_info_t)&data[i].host_vm_info_rev0, &count), NULL);
127 count = HOST_VM_INFO_REV1_COUNT;
128 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_VM_INFO, (host_info_t)&data[i].host_vm_info_rev1, &count), NULL);
129 count = HOST_VM_INFO_REV2_COUNT;
130 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_VM_INFO, (host_info_t)&data[i].host_vm_info_rev2, &count), NULL);
131 count = HOST_CPU_LOAD_INFO_COUNT;
132 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_CPU_LOAD_INFO, (host_info_t)&data[i].host_cpu_load_info, &count), NULL);
133 count = TASK_POWER_INFO_COUNT;
134 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_EXPIRED_TASK_INFO, (host_info_t)&data[i].host_expired_task_info, &count), NULL);
135 count = TASK_POWER_INFO_V2_COUNT;
136 T_QUIET; T_ASSERT_POSIX_ZERO(host_statistics(self, HOST_EXPIRED_TASK_INFO, (host_info_t)&data[i].host_expired_task_info2, &count), NULL);
137 }
138 }
139
140 T_DECL(test_host_statistics, "testing rate limit for host_statistics",
141 T_META_CHECK_LEAKS(false), T_META_ALL_VALID_ARCHS(true))
142 {
143 unsigned long long start, end, window;
144 int retry = 0;
145 host_t self;
146 char lett = 'a';
147 struct all_host_info* data;
148 mach_timebase_info_data_t timebaseInfo = { 0, 0 };
149
150 if (remove_platform_binary()) {
151 T_SKIP("Failed to remove platform binary");
152 }
153
154 data = malloc(ITER * sizeof(struct all_host_info));
155 T_QUIET; T_ASSERT_NE(data, NULL, "malloc");
156
157 /* check the size of the data structure against the bytes in COUNT*/
158 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_vm_info64_rev0), HOST_VM_INFO64_COUNT * sizeof(int), "HOST_VM_INFO64_COUNT");
159 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_extmod_info64), HOST_EXTMOD_INFO64_COUNT * sizeof(int), "HOST_EXTMOD_INFO64_COUNT");
160 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_load_info), HOST_LOAD_INFO_COUNT * sizeof(int), "HOST_LOAD_INFO_COUNT");
161 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_vm_info_rev0), HOST_VM_INFO_COUNT * sizeof(int), "HOST_VM_INFO_COUNT");
162 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_cpu_load_info), HOST_CPU_LOAD_INFO_COUNT * sizeof(int), "HOST_CPU_LOAD_INFO_COUNT");
163 T_QUIET; T_ASSERT_EQ(sizeof(data[0].host_expired_task_info2), TASK_POWER_INFO_V2_COUNT * sizeof(int), "TASK_POWER_INFO_V2_COUNT");
164
165 /* check that the latest revision is the COUNT */
166 T_QUIET; T_ASSERT_EQ(HOST_VM_INFO64_REV1_COUNT, HOST_VM_INFO64_COUNT, "HOST_VM_INFO64_REV1_COUNT");
167 T_QUIET; T_ASSERT_EQ(HOST_VM_INFO_REV2_COUNT, HOST_VM_INFO_COUNT, "HOST_VM_INFO_REV2_COUNT");
168
169 /* check that the previous revision are smaller than the latest */
170 T_QUIET; T_ASSERT_LE(HOST_VM_INFO64_REV0_COUNT, HOST_VM_INFO64_REV1_COUNT, "HOST_VM_INFO64_REV0");
171 T_QUIET; T_ASSERT_LE(HOST_VM_INFO_REV0_COUNT, HOST_VM_INFO_REV2_COUNT, "HOST_VM_INFO_REV0_COUNT");
172 T_QUIET; T_ASSERT_LE(HOST_VM_INFO_REV1_COUNT, HOST_VM_INFO_REV2_COUNT, "HOST_VM_INFO_REV1_COUNT");
173 T_QUIET; T_ASSERT_LE(TASK_POWER_INFO_COUNT, TASK_POWER_INFO_V2_COUNT, "TASK_POWER_INFO_COUNT");
174
175 memset(data, lett, ITER * sizeof(struct all_host_info));
176 self = mach_host_self();
177
178 T_QUIET; T_ASSERT_EQ(mach_timebase_info(&timebaseInfo), KERN_SUCCESS, NULL);
179 window = (WINDOW * NSEC_PER_SEC * timebaseInfo.denom) / timebaseInfo.numer;
180 retry = 0;
181
182 /* try to get ITER copies of host_info within window time, in such a way we should hit for sure a cached copy */
183 do {
184 start = mach_continuous_time();
185 get_host_info(data, self, ITER);
186 end = mach_continuous_time();
187 retry++;
188 } while ((end - start > window) && retry <= RETRY);
189
190 if (retry <= RETRY) {
191 check_host_info(data, ITER, lett);
192 } else {
193 T_SKIP("Failed to find window for test");
194 }
195 }
196