chiark / gitweb /
test-json: use fabs
[elogind.git] / src / shared / virt.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <string.h>
23 #include <errno.h>
24 #include <unistd.h>
25
26 #include "util.h"
27 #include "virt.h"
28 #include "fileio.h"
29
30 static int detect_vm_cpuid(const char **_id) {
31
32         /* Both CPUID and DMI are x86 specific interfaces... */
33 #if defined(__i386__) || defined(__x86_64__)
34
35         static const char cpuid_vendor_table[] =
36                 "XenVMMXenVMM\0"          "xen\0"
37                 "KVMKVMKVM\0"             "kvm\0"
38                 /* http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458 */
39                 "VMwareVMware\0"          "vmware\0"
40                 /* http://msdn.microsoft.com/en-us/library/ff542428.aspx */
41                 "Microsoft Hv\0"          "microsoft\0";
42
43         uint32_t eax, ecx;
44         union {
45                 uint32_t sig32[3];
46                 char text[13];
47         } sig = {};
48         const char *j, *k;
49         bool hypervisor;
50
51         /* http://lwn.net/Articles/301888/ */
52
53 #if defined (__i386__)
54 #define REG_a "eax"
55 #define REG_b "ebx"
56 #elif defined (__amd64__)
57 #define REG_a "rax"
58 #define REG_b "rbx"
59 #endif
60
61         /* First detect whether there is a hypervisor */
62         eax = 1;
63         __asm__ __volatile__ (
64                 /* ebx/rbx is being used for PIC! */
65                 "  push %%"REG_b"         \n\t"
66                 "  cpuid                  \n\t"
67                 "  pop %%"REG_b"          \n\t"
68
69                 : "=a" (eax), "=c" (ecx)
70                 : "0" (eax)
71         );
72
73         hypervisor = !!(ecx & 0x80000000U);
74
75         if (hypervisor) {
76
77                 /* There is a hypervisor, see what it is */
78                 eax = 0x40000000U;
79                 __asm__ __volatile__ (
80                         /* ebx/rbx is being used for PIC! */
81                         "  push %%"REG_b"         \n\t"
82                         "  cpuid                  \n\t"
83                         "  mov %%ebx, %1          \n\t"
84                         "  pop %%"REG_b"          \n\t"
85
86                         : "=a" (eax), "=r" (sig.sig32[0]), "=c" (sig.sig32[1]), "=d" (sig.sig32[2])
87                         : "0" (eax)
88                 );
89
90                 NULSTR_FOREACH_PAIR(j, k, cpuid_vendor_table)
91                         if (streq(sig.text, j)) {
92                                 *_id = k;
93                                 return 1;
94                         }
95
96                 *_id = "other";
97                 return 0;
98         }
99 #endif
100
101         return 0;
102 }
103
104 static int detect_vm_dmi(const char **_id) {
105
106         /* Both CPUID and DMI are x86 specific interfaces... */
107 #if defined(__i386__) || defined(__x86_64__)
108
109         static const char *const dmi_vendors[] = {
110                 "/sys/class/dmi/id/sys_vendor",
111                 "/sys/class/dmi/id/board_vendor",
112                 "/sys/class/dmi/id/bios_vendor"
113         };
114
115         static const char dmi_vendor_table[] =
116                 "QEMU\0"                  "qemu\0"
117                 /* http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458 */
118                 "VMware\0"                "vmware\0"
119                 "VMW\0"                   "vmware\0"
120                 "innotek GmbH\0"          "oracle\0"
121                 "Xen\0"                   "xen\0"
122                 "Bochs\0"                 "bochs\0";
123         unsigned i;
124
125         for (i = 0; i < ELEMENTSOF(dmi_vendors); i++) {
126                 _cleanup_free_ char *s = NULL;
127                 const char *j, *k;
128                 int r;
129
130                 r = read_one_line_file(dmi_vendors[i], &s);
131                 if (r < 0) {
132                         if (r != -ENOENT)
133                                 return r;
134
135                         continue;
136                 }
137
138                 NULSTR_FOREACH_PAIR(j, k, dmi_vendor_table)
139                         if (startswith(s, j)) {
140                                 *_id = k;
141                                 return 1;
142                         }
143         }
144 #endif
145
146         return 0;
147 }
148
149 /* Returns a short identifier for the various VM implementations */
150 int detect_vm(const char **id) {
151         _cleanup_free_ char *domcap = NULL, *cpuinfo_contents = NULL;
152         static thread_local int cached_found = -1;
153         static thread_local const char *cached_id = NULL;
154         const char *_id = NULL;
155         int r;
156
157         if (_likely_(cached_found >= 0)) {
158
159                 if (id)
160                         *id = cached_id;
161
162                 return cached_found;
163         }
164
165         /* Try xen capabilities file first, if not found try high-level hypervisor sysfs file:
166          *
167          * https://bugs.freedesktop.org/show_bug.cgi?id=77271 */
168         r = read_one_line_file("/proc/xen/capabilities", &domcap);
169         if (r >= 0) {
170                 char *cap, *i = domcap;
171
172                 while ((cap = strsep(&i, ",")))
173                         if (streq(cap, "control_d"))
174                                 break;
175
176                 if (!cap)  {
177                         _id = "xen";
178                         r = 1;
179                 }
180
181                 goto finish;
182
183         } else if (r == -ENOENT) {
184                 _cleanup_free_ char *hvtype = NULL;
185
186                 r = read_one_line_file("/sys/hypervisor/type", &hvtype);
187                 if (r >= 0) {
188                         if (streq(hvtype, "xen")) {
189                                 _id = "xen";
190                                 r = 1;
191                                 goto finish;
192                         }
193                 } else if (r != -ENOENT)
194                         return r;
195         } else
196                 return r;
197
198         /* this will set _id to "other" and return 0 for unknown hypervisors */
199         r = detect_vm_cpuid(&_id);
200         if (r != 0)
201                 goto finish;
202
203         r = detect_vm_dmi(&_id);
204         if (r != 0)
205                 goto finish;
206
207         if (_id) {
208                 /* "other" */
209                 r = 1;
210                 goto finish;
211         }
212
213         /* Detect User-Mode Linux by reading /proc/cpuinfo */
214         r = read_full_file("/proc/cpuinfo", &cpuinfo_contents, NULL);
215         if (r < 0)
216                 return r;
217         if (strstr(cpuinfo_contents, "\nvendor_id\t: User Mode Linux\n")) {
218                 _id = "uml";
219                 r = 1;
220                 goto finish;
221         }
222
223 #if defined(__s390__)
224         {
225                 _cleanup_free_ char *t = NULL;
226
227                 r = get_status_field("/proc/sysinfo", "VM00 Control Program:", &t);
228                 if (r >= 0) {
229                         if (streq(t, "z/VM"))
230                                 _id = "zvm";
231                         else
232                                 _id = "kvm";
233                         r = 1;
234
235                         goto finish;
236                 }
237         }
238 #endif
239
240         r = 0;
241
242 finish:
243         cached_found = r;
244
245         cached_id = _id;
246         if (id)
247                 *id = _id;
248
249         return r;
250 }
251
252 int detect_container(const char **id) {
253
254         static thread_local int cached_found = -1;
255         static thread_local const char *cached_id = NULL;
256
257         _cleanup_free_ char *m = NULL;
258         const char *_id = NULL, *e = NULL;
259         int r;
260
261         if (_likely_(cached_found >= 0)) {
262
263                 if (id)
264                         *id = cached_id;
265
266                 return cached_found;
267         }
268
269         /* /proc/vz exists in container and outside of the container,
270          * /proc/bc only outside of the container. */
271         if (access("/proc/vz", F_OK) >= 0 &&
272             access("/proc/bc", F_OK) < 0) {
273                 _id = "openvz";
274                 r = 1;
275                 goto finish;
276         }
277
278         if (getpid() == 1) {
279                 /* If we are PID 1 we can just check our own
280                  * environment variable */
281
282                 e = getenv("container");
283                 if (isempty(e)) {
284                         r = 0;
285                         goto finish;
286                 }
287         } else {
288
289                 /* Otherwise, PID 1 dropped this information into a
290                  * file in /run. This is better than accessing
291                  * /proc/1/environ, since we don't need CAP_SYS_PTRACE
292                  * for that. */
293
294                 r = read_one_line_file("/run/systemd/container", &m);
295                 if (r == -ENOENT) {
296
297                         /* Fallback for cases where PID 1 was not
298                          * systemd (for example, cases where
299                          * init=/bin/sh is used. */
300
301                         r = getenv_for_pid(1, "container", &m);
302                         if (r <= 0) {
303
304                                 /* If that didn't work, give up,
305                                  * assume no container manager.
306                                  *
307                                  * Note: This means we still cannot
308                                  * detect containers if init=/bin/sh
309                                  * is passed but privileges dropped,
310                                  * as /proc/1/environ is only readable
311                                  * with privileges. */
312
313                                 r = 0;
314                                 goto finish;
315                         }
316                 }
317                 if (r < 0)
318                         return r;
319
320                 e = m;
321         }
322
323         /* We only recognize a selected few here, since we want to
324          * enforce a redacted namespace */
325         if (streq(e, "lxc"))
326                 _id ="lxc";
327         else if (streq(e, "lxc-libvirt"))
328                 _id = "lxc-libvirt";
329         else if (streq(e, "systemd-nspawn"))
330                 _id = "systemd-nspawn";
331         else if (streq(e, "docker"))
332                 _id = "docker";
333         else
334                 _id = "other";
335
336         r = 1;
337
338 finish:
339         cached_found = r;
340
341         cached_id = _id;
342         if (id)
343                 *id = _id;
344
345         return r;
346 }
347
348 /* Returns a short identifier for the various VM/container implementations */
349 int detect_virtualization(const char **id) {
350         int r;
351
352         r = detect_container(id);
353         if (r < 0)
354                 return r;
355         if (r > 0)
356                 return VIRTUALIZATION_CONTAINER;
357
358         r = detect_vm(id);
359         if (r < 0)
360                 return r;
361         if (r > 0)
362                 return VIRTUALIZATION_VM;
363
364         return VIRTUALIZATION_NONE;
365 }