xref: /openbmc/qemu/tools/i386/qemu-vmsr-helper.c (revision a6896ebc) 
1 /*
2  * Privileged RAPL MSR helper commands for QEMU
3  *
4  * Copyright (C) 2024 Red Hat, Inc. <aharivel@redhat.com>
5  *
6  * Author: Anthony Harivel <aharivel@redhat.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; under version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20 
21 #include "qemu/osdep.h"
22 #include <getopt.h>
23 #include <stdbool.h>
24 #include <sys/ioctl.h>
25 #ifdef CONFIG_LIBCAP_NG
26 #include <cap-ng.h>
27 #endif
28 #include <pwd.h>
29 #include <grp.h>
30 
31 #include "qemu/help-texts.h"
32 #include "qapi/error.h"
33 #include "qemu/cutils.h"
34 #include "qemu/main-loop.h"
35 #include "qemu/module.h"
36 #include "qemu/error-report.h"
37 #include "qemu/config-file.h"
38 #include "qemu-version.h"
39 #include "qapi/error.h"
40 #include "qemu/error-report.h"
41 #include "qemu/log.h"
42 #include "qemu/systemd.h"
43 #include "io/channel.h"
44 #include "io/channel-socket.h"
45 #include "trace/control.h"
46 #include "qemu-version.h"
47 #include "rapl-msr-index.h"
48 
49 #define MSR_PATH_TEMPLATE "/dev/cpu/%u/msr"
50 
51 static char *socket_path;
52 static char *pidfile;
53 static enum { RUNNING, TERMINATE, TERMINATING } state;
54 static QIOChannelSocket *server_ioc;
55 static int server_watch;
56 static int num_active_sockets = 1;
57 static bool verbose;
58 
59 #ifdef CONFIG_LIBCAP_NG
60 static int uid = -1;
61 static int gid = -1;
62 #endif
63 
64 static void compute_default_paths(void)
65 {
66     g_autofree char *state = qemu_get_local_state_dir();
67 
68     socket_path = g_build_filename(state, "run", "qemu-vmsr-helper.sock", NULL);
69     pidfile = g_build_filename(state, "run", "qemu-vmsr-helper.pid", NULL);
70 }
71 
72 static int is_intel_processor(void)
73 {
74     int result;
75     int ebx, ecx, edx;
76 
77     /* Execute CPUID instruction with eax=0 (basic identification) */
78     asm volatile (
79         "cpuid"
80         : "=b" (ebx), "=c" (ecx), "=d" (edx)
81         : "a" (0)
82     );
83 
84     /*
85      *  Check if processor is "GenuineIntel"
86      *  0x756e6547 = "Genu"
87      *  0x49656e69 = "ineI"
88      *  0x6c65746e = "ntel"
89      */
90     result = (ebx == 0x756e6547) && (edx == 0x49656e69) && (ecx == 0x6c65746e);
91 
92     return result;
93 }
94 
95 static int is_rapl_enabled(void)
96 {
97     const char *path = "/sys/class/powercap/intel-rapl/enabled";
98     FILE *file = fopen(path, "r");
99     int value = 0;
100 
101     if (file != NULL) {
102         if (fscanf(file, "%d", &value) != 1) {
103             error_report("INTEL RAPL not enabled");
104         }
105         fclose(file);
106     } else {
107         error_report("Error opening %s", path);
108     }
109 
110     return value;
111 }
112 
113 /*
114  * Check if the TID that request the MSR read
115  * belongs to the peer. It be should a TID of a vCPU.
116  */
117 static bool is_tid_present(pid_t pid, pid_t tid)
118 {
119     g_autofree char *tidPath = g_strdup_printf("/proc/%d/task/%d", pid, tid);
120 
121     /* Check if the TID directory exists within the PID directory */
122     if (access(tidPath, F_OK) == 0) {
123         return true;
124     }
125 
126     error_report("Failed to open /proc at %s", tidPath);
127     return false;
128 }
129 
130 /*
131  * Only the RAPL MSR in target/i386/cpu.h are allowed
132  */
133 static bool is_msr_allowed(uint32_t reg)
134 {
135     switch (reg) {
136     case MSR_RAPL_POWER_UNIT:
137     case MSR_PKG_POWER_LIMIT:
138     case MSR_PKG_ENERGY_STATUS:
139     case MSR_PKG_POWER_INFO:
140         return true;
141     default:
142         return false;
143     }
144 }
145 
146 static uint64_t vmsr_read_msr(uint32_t msr_register, unsigned int cpu_id)
147 {
148     int fd;
149     uint64_t result = 0;
150 
151     g_autofree char *path = g_strdup_printf(MSR_PATH_TEMPLATE, cpu_id);
152 
153     fd = open(path, O_RDONLY);
154     if (fd < 0) {
155         error_report("Failed to open MSR file at %s", path);
156         return result;
157     }
158 
159     if (pread(fd, &result, sizeof(result), msr_register) != sizeof(result)) {
160         error_report("Failed to read MSR");
161         result = 0;
162     }
163 
164     close(fd);
165     return result;
166 }
167 
168 static void usage(const char *name)
169 {
170     (printf) (
171 "Usage: %s [OPTIONS] FILE\n"
172 "Virtual RAPL MSR helper program for QEMU\n"
173 "\n"
174 "  -h, --help                display this help and exit\n"
175 "  -V, --version             output version information and exit\n"
176 "\n"
177 "  -d, --daemon              run in the background\n"
178 "  -f, --pidfile=PATH        PID file when running as a daemon\n"
179 "                            (default '%s')\n"
180 "  -k, --socket=PATH         path to the unix socket\n"
181 "                            (default '%s')\n"
182 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
183 "                            specify tracing options\n"
184 #ifdef CONFIG_LIBCAP_NG
185 "  -u, --user=USER           user to drop privileges to\n"
186 "  -g, --group=GROUP         group to drop privileges to\n"
187 #endif
188 "\n"
189 QEMU_HELP_BOTTOM "\n"
190     , name, pidfile, socket_path);
191 }
192 
193 static void version(const char *name)
194 {
195     printf(
196 "%s " QEMU_FULL_VERSION "\n"
197 "Written by Anthony Harivel.\n"
198 "\n"
199 QEMU_COPYRIGHT "\n"
200 "This is free software; see the source for copying conditions.  There is NO\n"
201 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
202     , name);
203 }
204 
205 typedef struct VMSRHelperClient {
206     QIOChannelSocket *ioc;
207     Coroutine *co;
208 } VMSRHelperClient;
209 
210 static void coroutine_fn vh_co_entry(void *opaque)
211 {
212     VMSRHelperClient *client = opaque;
213     Error *local_err = NULL;
214     unsigned int peer_pid;
215     uint32_t request[3];
216     uint64_t vmsr;
217     int r;
218 
219     qio_channel_set_blocking(QIO_CHANNEL(client->ioc),
220                              false, NULL);
221 
222     qio_channel_set_follow_coroutine_ctx(QIO_CHANNEL(client->ioc), true);
223 
224     /*
225      * Check peer credentials
226      */
227     r = qio_channel_get_peerpid(QIO_CHANNEL(client->ioc),
228                                 &peer_pid,
229                                 &local_err);
230     if (r < 0) {
231         goto out;
232     }
233 
234     for (;;) {
235         /*
236          * Read the requested MSR
237          * Only RAPL MSR in rapl-msr-index.h is allowed
238          */
239         r = qio_channel_read_all_eof(QIO_CHANNEL(client->ioc),
240                                      (char *) &request, sizeof(request), &local_err);
241         if (r <= 0) {
242             break;
243         }
244 
245         if (!is_msr_allowed(request[0])) {
246             error_report("Requested unallowed msr: %d", request[0]);
247             break;
248         }
249 
250         vmsr = vmsr_read_msr(request[0], request[1]);
251 
252         if (!is_tid_present(peer_pid, request[2])) {
253             error_report("Requested TID not in peer PID: %d %d",
254                 peer_pid, request[2]);
255             vmsr = 0;
256         }
257 
258         r = qio_channel_write_all(QIO_CHANNEL(client->ioc),
259                                   (char *) &vmsr,
260                                   sizeof(vmsr),
261                                   &local_err);
262         if (r < 0) {
263             break;
264         }
265     }
266 
267 out:
268     if (local_err) {
269         if (!verbose) {
270             error_free(local_err);
271         } else {
272             error_report_err(local_err);
273         }
274     }
275 
276     object_unref(OBJECT(client->ioc));
277     g_free(client);
278 }
279 
280 static gboolean accept_client(QIOChannel *ioc,
281                               GIOCondition cond,
282                               gpointer opaque)
283 {
284     QIOChannelSocket *cioc;
285     VMSRHelperClient *vmsrh;
286 
287     cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
288                                      NULL);
289     if (!cioc) {
290         return TRUE;
291     }
292 
293     vmsrh = g_new(VMSRHelperClient, 1);
294     vmsrh->ioc = cioc;
295     vmsrh->co = qemu_coroutine_create(vh_co_entry, vmsrh);
296     qemu_coroutine_enter(vmsrh->co);
297 
298     return TRUE;
299 }
300 
301 static void termsig_handler(int signum)
302 {
303     qatomic_cmpxchg(&state, RUNNING, TERMINATE);
304     qemu_notify_event();
305 }
306 
307 static void close_server_socket(void)
308 {
309     assert(server_ioc);
310 
311     g_source_remove(server_watch);
312     server_watch = -1;
313     object_unref(OBJECT(server_ioc));
314     num_active_sockets--;
315 }
316 
317 #ifdef CONFIG_LIBCAP_NG
318 static int drop_privileges(void)
319 {
320     /* clear all capabilities */
321     capng_clear(CAPNG_SELECT_BOTH);
322 
323     if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
324                      CAP_SYS_RAWIO) < 0) {
325         return -1;
326     }
327 
328     return 0;
329 }
330 #endif
331 
332 int main(int argc, char **argv)
333 {
334     const char *sopt = "hVk:f:dT:u:g:vq";
335     struct option lopt[] = {
336         { "help", no_argument, NULL, 'h' },
337         { "version", no_argument, NULL, 'V' },
338         { "socket", required_argument, NULL, 'k' },
339         { "pidfile", required_argument, NULL, 'f' },
340         { "daemon", no_argument, NULL, 'd' },
341         { "trace", required_argument, NULL, 'T' },
342         { "verbose", no_argument, NULL, 'v' },
343         { NULL, 0, NULL, 0 }
344     };
345     int opt_ind = 0;
346     int ch;
347     Error *local_err = NULL;
348     bool daemonize = false;
349     bool pidfile_specified = false;
350     bool socket_path_specified = false;
351     unsigned socket_activation;
352 
353     struct sigaction sa_sigterm;
354     memset(&sa_sigterm, 0, sizeof(sa_sigterm));
355     sa_sigterm.sa_handler = termsig_handler;
356     sigaction(SIGTERM, &sa_sigterm, NULL);
357     sigaction(SIGINT, &sa_sigterm, NULL);
358     sigaction(SIGHUP, &sa_sigterm, NULL);
359 
360     signal(SIGPIPE, SIG_IGN);
361 
362     error_init(argv[0]);
363     module_call_init(MODULE_INIT_TRACE);
364     module_call_init(MODULE_INIT_QOM);
365     qemu_add_opts(&qemu_trace_opts);
366     qemu_init_exec_dir(argv[0]);
367 
368     compute_default_paths();
369 
370     /*
371      * Sanity check
372      * 1. cpu must be Intel cpu
373      * 2. RAPL must be enabled
374      */
375     if (!is_intel_processor()) {
376         error_report("error: CPU is not INTEL cpu");
377         exit(EXIT_FAILURE);
378     }
379 
380     if (!is_rapl_enabled()) {
381         error_report("error: RAPL driver not enable");
382         exit(EXIT_FAILURE);
383     }
384 
385     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
386         switch (ch) {
387         case 'k':
388             g_free(socket_path);
389             socket_path = g_strdup(optarg);
390             socket_path_specified = true;
391             if (socket_path[0] != '/') {
392                 error_report("socket path must be absolute");
393                 exit(EXIT_FAILURE);
394             }
395             break;
396         case 'f':
397             g_free(pidfile);
398             pidfile = g_strdup(optarg);
399             pidfile_specified = true;
400             break;
401 #ifdef CONFIG_LIBCAP_NG
402         case 'u': {
403             unsigned long res;
404             struct passwd *userinfo = getpwnam(optarg);
405             if (userinfo) {
406                 uid = userinfo->pw_uid;
407             } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 &&
408                        (uid_t)res == res) {
409                 uid = res;
410             } else {
411                 error_report("invalid user '%s'", optarg);
412                 exit(EXIT_FAILURE);
413             }
414             break;
415         }
416         case 'g': {
417             unsigned long res;
418             struct group *groupinfo = getgrnam(optarg);
419             if (groupinfo) {
420                 gid = groupinfo->gr_gid;
421             } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 &&
422                        (gid_t)res == res) {
423                 gid = res;
424             } else {
425                 error_report("invalid group '%s'", optarg);
426                 exit(EXIT_FAILURE);
427             }
428             break;
429         }
430 #else
431         case 'u':
432         case 'g':
433             error_report("-%c not supported by this %s", ch, argv[0]);
434             exit(1);
435 #endif
436         case 'd':
437             daemonize = true;
438             break;
439         case 'v':
440             verbose = true;
441             break;
442         case 'T':
443             trace_opt_parse(optarg);
444             break;
445         case 'V':
446             version(argv[0]);
447             exit(EXIT_SUCCESS);
448             break;
449         case 'h':
450             usage(argv[0]);
451             exit(EXIT_SUCCESS);
452             break;
453         case '?':
454             error_report("Try `%s --help' for more information.", argv[0]);
455             exit(EXIT_FAILURE);
456         }
457     }
458 
459     if (!trace_init_backends()) {
460         exit(EXIT_FAILURE);
461     }
462     trace_init_file();
463     qemu_set_log(LOG_TRACE, &error_fatal);
464 
465     socket_activation = check_socket_activation();
466     if (socket_activation == 0) {
467         SocketAddress saddr;
468         saddr = (SocketAddress){
469             .type = SOCKET_ADDRESS_TYPE_UNIX,
470             .u.q_unix.path = socket_path,
471         };
472         server_ioc = qio_channel_socket_new();
473         if (qio_channel_socket_listen_sync(server_ioc, &saddr,
474                                            1, &local_err) < 0) {
475             object_unref(OBJECT(server_ioc));
476             error_report_err(local_err);
477             return 1;
478         }
479     } else {
480         /* Using socket activation - check user didn't use -p etc. */
481         if (socket_path_specified) {
482             error_report("Unix socket can't be set when"
483                          "using socket activation");
484             exit(EXIT_FAILURE);
485         }
486 
487         /* Can only listen on a single socket.  */
488         if (socket_activation > 1) {
489             error_report("%s does not support socket activation"
490                          "with LISTEN_FDS > 1",
491                         argv[0]);
492             exit(EXIT_FAILURE);
493         }
494         server_ioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD,
495                                                &local_err);
496         if (server_ioc == NULL) {
497             error_reportf_err(local_err,
498                               "Failed to use socket activation: ");
499             exit(EXIT_FAILURE);
500         }
501     }
502 
503     qemu_init_main_loop(&error_fatal);
504 
505     server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc),
506                                          G_IO_IN,
507                                          accept_client,
508                                          NULL, NULL);
509 
510     if (daemonize) {
511         if (daemon(0, 0) < 0) {
512             error_report("Failed to daemonize: %s", strerror(errno));
513             exit(EXIT_FAILURE);
514         }
515     }
516 
517     if (daemonize || pidfile_specified) {
518         qemu_write_pidfile(pidfile, &error_fatal);
519     }
520 
521 #ifdef CONFIG_LIBCAP_NG
522     if (drop_privileges() < 0) {
523         error_report("Failed to drop privileges: %s", strerror(errno));
524         exit(EXIT_FAILURE);
525     }
526 #endif
527 
528     info_report("Listening on %s", socket_path);
529 
530     state = RUNNING;
531     do {
532         main_loop_wait(false);
533         if (state == TERMINATE) {
534             state = TERMINATING;
535             close_server_socket();
536         }
537     } while (num_active_sockets > 0);
538 
539     exit(EXIT_SUCCESS);
540 }
541