Merge tag 'pull-ppc-20211129' of https://github.com/legoater/qemu into staging
[qemu.git] / tests / migration / stress.c
1 /*
2 * Migration stress workload
3 *
4 * Copyright (c) 2016 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21 #include <getopt.h>
22 #include <sys/reboot.h>
23 #include <sys/syscall.h>
24 #include <linux/random.h>
25 #include <pthread.h>
26 #include <sys/mount.h>
27
28 const char *argv0;
29
30 #define RAM_PAGE_SIZE 4096
31
32 #ifndef CONFIG_GETTID
33 static int gettid(void)
34 {
35 return syscall(SYS_gettid);
36 }
37 #endif
38
39 static __attribute__((noreturn)) void exit_failure(void)
40 {
41 if (getpid() == 1) {
42 sync();
43 reboot(RB_POWER_OFF);
44 fprintf(stderr, "%s (%05d): ERROR: cannot reboot: %s\n",
45 argv0, gettid(), strerror(errno));
46 abort();
47 } else {
48 exit(1);
49 }
50 }
51
52 static int get_command_arg_str(const char *name,
53 char **val)
54 {
55 static char line[1024];
56 FILE *fp = fopen("/proc/cmdline", "r");
57 char *start, *end;
58
59 if (fp == NULL) {
60 fprintf(stderr, "%s (%05d): ERROR: cannot open /proc/cmdline: %s\n",
61 argv0, gettid(), strerror(errno));
62 return -1;
63 }
64
65 if (!fgets(line, sizeof line, fp)) {
66 fprintf(stderr, "%s (%05d): ERROR: cannot read /proc/cmdline: %s\n",
67 argv0, gettid(), strerror(errno));
68 fclose(fp);
69 return -1;
70 }
71 fclose(fp);
72
73 start = strstr(line, name);
74 if (!start)
75 return 0;
76
77 start += strlen(name);
78
79 if (*start != '=') {
80 fprintf(stderr, "%s (%05d): ERROR: no value provided for '%s' in /proc/cmdline\n",
81 argv0, gettid(), name);
82 }
83 start++;
84
85 end = strstr(start, " ");
86 if (!end)
87 end = strstr(start, "\n");
88
89 if (end == start) {
90 fprintf(stderr, "%s (%05d): ERROR: no value provided for '%s' in /proc/cmdline\n",
91 argv0, gettid(), name);
92 return -1;
93 }
94
95 if (end)
96 *val = g_strndup(start, end - start);
97 else
98 *val = g_strdup(start);
99 return 1;
100 }
101
102
103 static int get_command_arg_ull(const char *name,
104 unsigned long long *val)
105 {
106 char *valstr;
107 char *end;
108
109 int ret = get_command_arg_str(name, &valstr);
110 if (ret <= 0)
111 return ret;
112
113 errno = 0;
114 *val = strtoll(valstr, &end, 10);
115 if (errno || *end) {
116 fprintf(stderr, "%s (%05d): ERROR: cannot parse %s value %s\n",
117 argv0, gettid(), name, valstr);
118 g_free(valstr);
119 return -1;
120 }
121 g_free(valstr);
122 return 0;
123 }
124
125
126 static int random_bytes(char *buf, size_t len)
127 {
128 int fd;
129
130 fd = open("/dev/urandom", O_RDONLY);
131 if (fd < 0) {
132 fprintf(stderr, "%s (%05d): ERROR: cannot open /dev/urandom: %s\n",
133 argv0, gettid(), strerror(errno));
134 return -1;
135 }
136
137 if (read(fd, buf, len) != len) {
138 fprintf(stderr, "%s (%05d): ERROR: cannot read /dev/urandom: %s\n",
139 argv0, gettid(), strerror(errno));
140 close(fd);
141 return -1;
142 }
143
144 close(fd);
145
146 return 0;
147 }
148
149
150 static unsigned long long now(void)
151 {
152 struct timeval tv;
153
154 gettimeofday(&tv, NULL);
155
156 return (tv.tv_sec * 1000ull) + (tv.tv_usec / 1000ull);
157 }
158
159 static void stressone(unsigned long long ramsizeMB)
160 {
161 size_t pagesPerMB = 1024 * 1024 / RAM_PAGE_SIZE;
162 g_autofree char *ram = g_malloc(ramsizeMB * 1024 * 1024);
163 char *ramptr;
164 size_t i, j, k;
165 g_autofree char *data = g_malloc(RAM_PAGE_SIZE);
166 char *dataptr;
167 size_t nMB = 0;
168 unsigned long long before, after;
169
170 /* We don't care about initial state, but we do want
171 * to fault it all into RAM, otherwise the first iter
172 * of the loop below will be quite slow. We can't use
173 * 0x0 as the byte as gcc optimizes that away into a
174 * calloc instead :-) */
175 memset(ram, 0xfe, ramsizeMB * 1024 * 1024);
176
177 if (random_bytes(data, RAM_PAGE_SIZE) < 0) {
178 return;
179 }
180
181 before = now();
182
183 while (1) {
184
185 ramptr = ram;
186 for (i = 0; i < ramsizeMB; i++, nMB++) {
187 for (j = 0; j < pagesPerMB; j++) {
188 dataptr = data;
189 for (k = 0; k < RAM_PAGE_SIZE; k += sizeof(long long)) {
190 ramptr += sizeof(long long);
191 dataptr += sizeof(long long);
192 *(unsigned long long *)ramptr ^= *(unsigned long long *)dataptr;
193 }
194 }
195
196 if (nMB == 1024) {
197 after = now();
198 fprintf(stderr, "%s (%05d): INFO: %06llums copied 1 GB in %05llums\n",
199 argv0, gettid(), after, after - before);
200 before = now();
201 nMB = 0;
202 }
203 }
204 }
205 }
206
207
208 static void *stressthread(void *arg)
209 {
210 unsigned long long ramsizeMB = *(unsigned long long *)arg;
211
212 stressone(ramsizeMB);
213
214 return NULL;
215 }
216
217 static void stress(unsigned long long ramsizeGB, int ncpus)
218 {
219 size_t i;
220 unsigned long long ramsizeMB = ramsizeGB * 1024 / ncpus;
221 ncpus--;
222
223 for (i = 0; i < ncpus; i++) {
224 pthread_t thr;
225 pthread_create(&thr, NULL,
226 stressthread, &ramsizeMB);
227 }
228
229 stressone(ramsizeMB);
230 }
231
232
233 static int mount_misc(const char *fstype, const char *dir)
234 {
235 if (mkdir(dir, 0755) < 0 && errno != EEXIST) {
236 fprintf(stderr, "%s (%05d): ERROR: cannot create %s: %s\n",
237 argv0, gettid(), dir, strerror(errno));
238 return -1;
239 }
240
241 if (mount("none", dir, fstype, 0, NULL) < 0) {
242 fprintf(stderr, "%s (%05d): ERROR: cannot mount %s: %s\n",
243 argv0, gettid(), dir, strerror(errno));
244 return -1;
245 }
246
247 return 0;
248 }
249
250 static int mount_all(void)
251 {
252 if (mount_misc("proc", "/proc") < 0 ||
253 mount_misc("sysfs", "/sys") < 0 ||
254 mount_misc("tmpfs", "/dev") < 0)
255 return -1;
256
257 mknod("/dev/urandom", 0777 | S_IFCHR, makedev(1, 9));
258 mknod("/dev/random", 0777 | S_IFCHR, makedev(1, 8));
259
260 return 0;
261 }
262
263 int main(int argc, char **argv)
264 {
265 unsigned long long ramsizeGB = 1;
266 char *end;
267 int ch;
268 int opt_ind = 0;
269 const char *sopt = "hr:c:";
270 struct option lopt[] = {
271 { "help", no_argument, NULL, 'h' },
272 { "ramsize", required_argument, NULL, 'r' },
273 { "cpus", required_argument, NULL, 'c' },
274 { NULL, 0, NULL, 0 }
275 };
276 int ret;
277 int ncpus = 0;
278
279 argv0 = argv[0];
280
281 while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
282 switch (ch) {
283 case 'r':
284 errno = 0;
285 ramsizeGB = strtoll(optarg, &end, 10);
286 if (errno != 0 || *end) {
287 fprintf(stderr, "%s (%05d): ERROR: Cannot parse RAM size %s\n",
288 argv0, gettid(), optarg);
289 exit_failure();
290 }
291 break;
292
293 case 'c':
294 errno = 0;
295 ncpus = strtoll(optarg, &end, 10);
296 if (errno != 0 || *end) {
297 fprintf(stderr, "%s (%05d): ERROR: Cannot parse CPU count %s\n",
298 argv0, gettid(), optarg);
299 exit_failure();
300 }
301 break;
302
303 case '?':
304 case 'h':
305 fprintf(stderr, "%s: [--help][--ramsize GB][--cpus N]\n", argv0);
306 exit_failure();
307 }
308 }
309
310 if (getpid() == 1) {
311 if (mount_all() < 0)
312 exit_failure();
313
314 ret = get_command_arg_ull("ramsize", &ramsizeGB);
315 if (ret < 0)
316 exit_failure();
317 }
318
319 if (ncpus == 0)
320 ncpus = sysconf(_SC_NPROCESSORS_ONLN);
321
322 fprintf(stdout, "%s (%05d): INFO: RAM %llu GiB across %d CPUs\n",
323 argv0, gettid(), ramsizeGB, ncpus);
324
325 stress(ramsizeGB, ncpus);
326
327 exit_failure();
328 }