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 /* Returns a short identifier for the various VM implementations */
  31 int detect_vm(const char **id) {
  32
  33 #if defined(__i386__) || defined(__x86_64__)
  34
  35         /* Both CPUID and DMI are x86 specific interfaces... */
  36
  37         static const char *const dmi_vendors[] = {
  38                 "/sys/class/dmi/id/sys_vendor",
  39                 "/sys/class/dmi/id/board_vendor",
  40                 "/sys/class/dmi/id/bios_vendor"
  41         };
  42
  43         static const char dmi_vendor_table[] =
  44                 "QEMU\0"                  "qemu\0"
  45                 /* http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458 */
  46                 "VMware\0"                "vmware\0"
  47                 "VMW\0"                   "vmware\0"
  48                 "Microsoft Corporation\0" "microsoft\0"
  49                 "innotek GmbH\0"          "oracle\0"
  50                 "Xen\0"                   "xen\0"
  51                 "Bochs\0"                 "bochs\0";
  52
  53         static const char cpuid_vendor_table[] =
  54                 "XenVMMXenVMM\0"          "xen\0"
  55                 "KVMKVMKVM\0"             "kvm\0"
  56                 /* http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458 */
  57                 "VMwareVMware\0"          "vmware\0"
  58                 /* http://msdn.microsoft.com/en-us/library/ff542428.aspx */
  59                 "Microsoft Hv\0"          "microsoft\0";
  60
  61         uint32_t eax, ecx;
  62         union {
  63                 uint32_t sig32[3];
  64                 char text[13];
  65         } sig = {};
  66         unsigned i;
  67         const char *j, *k;
  68         bool hypervisor;
  69         _cleanup_free_ char *hvtype = NULL;
  70         int r;
  71
  72         /* Try high-level hypervisor sysfs file first:
  73          *
  74          * https://bugs.freedesktop.org/show_bug.cgi?id=61491 */
  75         r = read_one_line_file("/sys/hypervisor/type", &hvtype);
  76         if (r >= 0) {
  77                 if (streq(hvtype, "xen")) {
  78                         if (id)
  79                                 *id = "xen";
  80
  81                         return 1;
  82                 }
  83         } else if (r != -ENOENT)
  84                 return r;
  85
  86         /* http://lwn.net/Articles/301888/ */
  87
  88 #if defined (__i386__)
  89 #define REG_a "eax"
  90 #define REG_b "ebx"
  91 #elif defined (__amd64__)
  92 #define REG_a "rax"
  93 #define REG_b "rbx"
  94 #endif
  95
  96         /* First detect whether there is a hypervisor */
  97         eax = 1;
  98         __asm__ __volatile__ (
  99                 /* ebx/rbx is being used for PIC! */
 100                 "  push %%"REG_b"         \n\t"
 101                 "  cpuid                  \n\t"
 102                 "  pop %%"REG_b"          \n\t"
 103
 104                 : "=a" (eax), "=c" (ecx)
 105                 : "0" (eax)
 106         );
 107
 108         hypervisor = !!(ecx & 0x80000000U);
 109
 110         if (hypervisor) {
 111
 112                 /* There is a hypervisor, see what it is */
 113                 eax = 0x40000000U;
 114                 __asm__ __volatile__ (
 115                         /* ebx/rbx is being used for PIC! */
 116                         "  push %%"REG_b"         \n\t"
 117                         "  cpuid                  \n\t"
 118                         "  mov %%ebx, %1          \n\t"
 119                         "  pop %%"REG_b"          \n\t"
 120
 121                         : "=a" (eax), "=r" (sig.sig32[0]), "=c" (sig.sig32[1]), "=d" (sig.sig32[2])
 122                         : "0" (eax)
 123                 );
 124
 125                 NULSTR_FOREACH_PAIR(j, k, cpuid_vendor_table)
 126                         if (streq(sig.text, j)) {
 127
 128                                 if (id)
 129                                         *id = k;
 130
 131                                 return 1;
 132                         }
 133         }
 134
 135         for (i = 0; i < ELEMENTSOF(dmi_vendors); i++) {
 136                 _cleanup_free_ char *s = NULL;
 137                 const char *found = NULL;
 138
 139                 r = read_one_line_file(dmi_vendors[i], &s);
 140                 if (r < 0) {
 141                         if (r != -ENOENT)
 142                                 return r;
 143
 144                         continue;
 145                 }
 146
 147                 NULSTR_FOREACH_PAIR(j, k, dmi_vendor_table)
 148                         if (startswith(s, j))
 149                                 found = k;
 150
 151                 if (found) {
 152                         if (id)
 153                                 *id = found;
 154
 155                         return 1;
 156                 }
 157         }
 158
 159         if (hypervisor || hvtype) {
 160                 if (id)
 161                         *id = "other";
 162
 163                 return 1;
 164         }
 165
 166 #endif
 167         return 0;
 168 }
 169
 170 int detect_container(const char **id) {
 171         _cleanup_free_ char *e = NULL;
 172         int r;
 173
 174         /* Unfortunately many of these operations require root access
 175          * in one way or another */
 176
 177         r = running_in_chroot();
 178         if (r < 0)
 179                 return r;
 180         if (r > 0) {
 181
 182                 if (id)
 183                         *id = "chroot";
 184
 185                 return 1;
 186         }
 187
 188         /* /proc/vz exists in container and outside of the container,
 189          * /proc/bc only outside of the container. */
 190         if (access("/proc/vz", F_OK) >= 0 &&
 191             access("/proc/bc", F_OK) < 0) {
 192
 193                 if (id)
 194                         *id = "openvz";
 195
 196                 return 1;
 197         }
 198
 199         r = getenv_for_pid(1, "container", &e);
 200         if (r <= 0)
 201                 return r;
 202
 203         /* We only recognize a selected few here, since we want to
 204          * enforce a redacted namespace */
 205         if (streq(e, "lxc")) {
 206                 if (id)
 207                         *id = "lxc";
 208         } else if (streq(e, "lxc-libvirt")) {
 209                 if (id)
 210                         *id = "lxc-libvirt";
 211         } else if (streq(e, "systemd-nspawn")) {
 212                 if (id)
 213                         *id = "systemd-nspawn";
 214         } else {
 215                 if (id)
 216                         *id = "other";
 217         }
 218
 219         return r;
 220 }
 221
 222 /* Returns a short identifier for the various VM/container implementations */
 223 Virtualization detect_virtualization(const char **id) {
 224
 225         static __thread Virtualization cached_virt = _VIRTUALIZATION_INVALID;
 226         static __thread const char *cached_id = NULL;
 227
 228         const char *_id;
 229         int r;
 230         Virtualization v;
 231
 232         if (_likely_(cached_virt >= 0)) {
 233
 234                 if (id && cached_virt > 0)
 235                         *id = cached_id;
 236
 237                 return cached_virt;
 238         }
 239
 240         r = detect_container(&_id);
 241         if (r < 0) {
 242                 v = r;
 243                 goto finish;
 244         } else if (r > 0) {
 245                 v = VIRTUALIZATION_CONTAINER;
 246                 goto finish;
 247         }
 248
 249         r = detect_vm(&_id);
 250         if (r < 0) {
 251                 v = r;
 252                 goto finish;
 253         } else if (r > 0) {
 254                 v = VIRTUALIZATION_VM;
 255                 goto finish;
 256         }
 257
 258         v = VIRTUALIZATION_NONE;
 259
 260 finish:
 261         if (v > 0) {
 262                 cached_id = _id;
 263
 264                 if (id)
 265                         *id = _id;
 266         }
 267
 268         if (v >= 0)
 269                 cached_virt = v;
 270
 271         return v;
 272 }