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         zero(sig);
  88
  89 #if defined (__i386__)
  90 #define REG_a "eax"
  91 #define REG_b "ebx"
  92 #elif defined (__amd64__)
  93 #define REG_a "rax"
  94 #define REG_b "rbx"
  95 #endif
  96
  97         /* First detect whether there is a hypervisor */
  98         eax = 1;
  99         __asm__ __volatile__ (
 100                 /* ebx/rbx is being used for PIC! */
 101                 "  push %%"REG_b"         \n\t"
 102                 "  cpuid                  \n\t"
 103                 "  pop %%"REG_b"          \n\t"
 104
 105                 : "=a" (eax), "=c" (ecx)
 106                 : "0" (eax)
 107         );
 108
 109         hypervisor = !!(ecx & 0x80000000U);
 110
 111         if (hypervisor) {
 112
 113                 /* There is a hypervisor, see what it is */
 114                 eax = 0x40000000U;
 115                 __asm__ __volatile__ (
 116                         /* ebx/rbx is being used for PIC! */
 117                         "  push %%"REG_b"         \n\t"
 118                         "  cpuid                  \n\t"
 119                         "  mov %%ebx, %1          \n\t"
 120                         "  pop %%"REG_b"          \n\t"
 121
 122                         : "=a" (eax), "=r" (sig.sig32[0]), "=c" (sig.sig32[1]), "=d" (sig.sig32[2])
 123                         : "0" (eax)
 124                 );
 125
 126                 NULSTR_FOREACH_PAIR(j, k, cpuid_vendor_table)
 127                         if (streq(sig.text, j)) {
 128
 129                                 if (id)
 130                                         *id = k;
 131
 132                                 return 1;
 133                         }
 134         }
 135
 136         for (i = 0; i < ELEMENTSOF(dmi_vendors); i++) {
 137                 _cleanup_free_ char *s = NULL;
 138                 const char *found = NULL;
 139
 140                 r = read_one_line_file(dmi_vendors[i], &s);
 141                 if (r < 0) {
 142                         if (r != -ENOENT)
 143                                 return r;
 144
 145                         continue;
 146                 }
 147
 148                 NULSTR_FOREACH_PAIR(j, k, dmi_vendor_table)
 149                         if (startswith(s, j))
 150                                 found = k;
 151
 152                 if (found) {
 153                         if (id)
 154                                 *id = found;
 155
 156                         return 1;
 157                 }
 158         }
 159
 160         if (hypervisor || hvtype) {
 161                 if (id)
 162                         *id = "other";
 163
 164                 return 1;
 165         }
 166
 167 #endif
 168         return 0;
 169 }
 170
 171 int detect_container(const char **id) {
 172         char *e = NULL;
 173         int r;
 174
 175         /* Unfortunately many of these operations require root access
 176          * in one way or another */
 177
 178         r = running_in_chroot();
 179         if (r < 0)
 180                 return r;
 181         if (r > 0) {
 182
 183                 if (id)
 184                         *id = "chroot";
 185
 186                 return 1;
 187         }
 188
 189         /* /proc/vz exists in container and outside of the container,
 190          * /proc/bc only outside of the container. */
 191         if (access("/proc/vz", F_OK) >= 0 &&
 192             access("/proc/bc", F_OK) < 0) {
 193
 194                 if (id)
 195                         *id = "openvz";
 196
 197                 return 1;
 198         }
 199
 200         r = getenv_for_pid(1, "container", &e);
 201         if (r <= 0)
 202                 return r;
 203
 204         /* We only recognize a selected few here, since we want to
 205          * enforce a redacted namespace */
 206         if (streq(e, "lxc")) {
 207                 if (id)
 208                         *id = "lxc";
 209         } else if (streq(e, "lxc-libvirt")) {
 210                 if (id)
 211                         *id = "lxc-libvirt";
 212         } else if (streq(e, "systemd-nspawn")) {
 213                 if (id)
 214                         *id = "systemd-nspawn";
 215         } else {
 216                 if (id)
 217                         *id = "other";
 218         }
 219
 220         free(e);
 221
 222         return r;
 223 }
 224
 225 /* Returns a short identifier for the various VM/container implementations */
 226 Virtualization detect_virtualization(const char **id) {
 227
 228         static __thread Virtualization cached_virt = _VIRTUALIZATION_INVALID;
 229         static __thread const char *cached_id = NULL;
 230
 231         const char *_id;
 232         int r;
 233         Virtualization v;
 234
 235         if (_likely_(cached_virt >= 0)) {
 236
 237                 if (id && cached_virt > 0)
 238                         *id = cached_id;
 239
 240                 return cached_virt;
 241         }
 242
 243         r = detect_container(&_id);
 244         if (r < 0) {
 245                 v = r;
 246                 goto finish;
 247         } else if (r > 0) {
 248                 v = VIRTUALIZATION_CONTAINER;
 249                 goto finish;
 250         }
 251
 252         r = detect_vm(&_id);
 253         if (r < 0) {
 254                 v = r;
 255                 goto finish;
 256         } else if (r > 0) {
 257                 v = VIRTUALIZATION_VM;
 258                 goto finish;
 259         }
 260
 261         v = VIRTUALIZATION_NONE;
 262
 263 finish:
 264         if (v > 0) {
 265                 cached_id = _id;
 266
 267                 if (id)
 268                         *id = _id;
 269         }
 270
 271         if (v >= 0)
 272                 cached_virt = v;
 273
 274         return v;
 275 }