driver/sysfs.c

   1 /*
   2  * Jailhouse, a Linux-based partitioning hypervisor
   3  *
   4  * Copyright (c) Siemens AG, 2014-2015
   5  *
   6  * Authors:
   7  *  Jan Kiszka <jan.kiszka@siemens.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  */
  12
  13 #include "cell.h"
  14 #include "jailhouse.h"
  15 #include "main.h"
  16 #include "sysfs.h"
  17
  18 #include <jailhouse/hypercall.h>
  19
  20 /* For compatibility with older kernel versions */
  21 #include <linux/version.h>
  22
  23 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
  24 #define DEVICE_ATTR_RO(_name) \
  25         struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
  26 #endif /* < 3.11 */
  27
  28 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0)
  29 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
  30                               char *buf)
  31 {
  32         struct kobj_attribute *kattr;
  33         ssize_t ret = -EIO;
  34
  35         kattr = container_of(attr, struct kobj_attribute, attr);
  36         if (kattr->show)
  37                 ret = kattr->show(kobj, kattr, buf);
  38         return ret;
  39 }
  40
  41 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
  42                                const char *buf, size_t count)
  43 {
  44         struct kobj_attribute *kattr;
  45         ssize_t ret = -EIO;
  46
  47         kattr = container_of(attr, struct kobj_attribute, attr);
  48         if (kattr->store)
  49                 ret = kattr->store(kobj, kattr, buf, count);
  50         return ret;
  51 }
  52
  53 static const struct sysfs_ops cell_sysfs_ops = {
  54         .show   = kobj_attr_show,
  55         .store  = kobj_attr_store,
  56 };
  57 #define kobj_sysfs_ops cell_sysfs_ops
  58 #endif /* < 3.14 */
  59 /* End of compatibility section - remove as version become obsolete */
  60
  61 static struct kobject *cells_dir;
  62
  63 struct jailhouse_cpu_stats_attr {
  64         struct kobj_attribute kattr;
  65         unsigned int code;
  66 };
  67
  68 static ssize_t stats_show(struct kobject *kobj, struct kobj_attribute *attr,
  69                           char *buffer)
  70 {
  71         struct jailhouse_cpu_stats_attr *stats_attr =
  72                 container_of(attr, struct jailhouse_cpu_stats_attr, kattr);
  73         unsigned int code = JAILHOUSE_CPU_INFO_STAT_BASE + stats_attr->code;
  74         struct cell *cell = container_of(kobj, struct cell, kobj);
  75         unsigned long sum = 0;
  76         unsigned int cpu;
  77         int value;
  78
  79         for_each_cpu(cpu, &cell->cpus_assigned) {
  80                 value = jailhouse_call_arg2(JAILHOUSE_HC_CPU_GET_INFO, cpu,
  81                                             code);
  82                 if (value > 0)
  83                         sum += value;
  84         }
  85
  86         return sprintf(buffer, "%lu\n", sum);
  87 }
  88
  89 #define JAILHOUSE_CPU_STATS_ATTR(_name, _code) \
  90         static struct jailhouse_cpu_stats_attr _name##_attr = { \
  91                 .kattr = __ATTR(_name, S_IRUGO, stats_show, NULL), \
  92                 .code = _code, \
  93         }
  94
  95 JAILHOUSE_CPU_STATS_ATTR(vmexits_total, JAILHOUSE_CPU_STAT_VMEXITS_TOTAL);
  96 JAILHOUSE_CPU_STATS_ATTR(vmexits_mmio, JAILHOUSE_CPU_STAT_VMEXITS_MMIO);
  97 JAILHOUSE_CPU_STATS_ATTR(vmexits_management,
  98                          JAILHOUSE_CPU_STAT_VMEXITS_MANAGEMENT);
  99 JAILHOUSE_CPU_STATS_ATTR(vmexits_hypercall,
 100                          JAILHOUSE_CPU_STAT_VMEXITS_HYPERCALL);
 101 #ifdef CONFIG_X86
 102 JAILHOUSE_CPU_STATS_ATTR(vmexits_pio, JAILHOUSE_CPU_STAT_VMEXITS_PIO);
 103 JAILHOUSE_CPU_STATS_ATTR(vmexits_xapic, JAILHOUSE_CPU_STAT_VMEXITS_XAPIC);
 104 JAILHOUSE_CPU_STATS_ATTR(vmexits_cr, JAILHOUSE_CPU_STAT_VMEXITS_CR);
 105 JAILHOUSE_CPU_STATS_ATTR(vmexits_msr, JAILHOUSE_CPU_STAT_VMEXITS_MSR);
 106 JAILHOUSE_CPU_STATS_ATTR(vmexits_cpuid, JAILHOUSE_CPU_STAT_VMEXITS_CPUID);
 107 JAILHOUSE_CPU_STATS_ATTR(vmexits_xsetbv, JAILHOUSE_CPU_STAT_VMEXITS_XSETBV);
 108 #elif defined(CONFIG_ARM)
 109 JAILHOUSE_CPU_STATS_ATTR(vmexits_maintenance, JAILHOUSE_CPU_STAT_VMEXITS_MAINTENANCE);
 110 JAILHOUSE_CPU_STATS_ATTR(vmexits_virt_irq, JAILHOUSE_CPU_STAT_VMEXITS_VIRQ);
 111 JAILHOUSE_CPU_STATS_ATTR(vmexits_virt_sgi, JAILHOUSE_CPU_STAT_VMEXITS_VSGI);
 112 #endif
 113
 114 static struct attribute *no_attrs[] = {
 115         &vmexits_total_attr.kattr.attr,
 116         &vmexits_mmio_attr.kattr.attr,
 117         &vmexits_management_attr.kattr.attr,
 118         &vmexits_hypercall_attr.kattr.attr,
 119 #ifdef CONFIG_X86
 120         &vmexits_pio_attr.kattr.attr,
 121         &vmexits_xapic_attr.kattr.attr,
 122         &vmexits_cr_attr.kattr.attr,
 123         &vmexits_msr_attr.kattr.attr,
 124         &vmexits_cpuid_attr.kattr.attr,
 125         &vmexits_xsetbv_attr.kattr.attr,
 126 #elif defined(CONFIG_ARM)
 127         &vmexits_maintenance_attr.kattr.attr,
 128         &vmexits_virt_irq_attr.kattr.attr,
 129         &vmexits_virt_sgi_attr.kattr.attr,
 130 #endif
 131         NULL
 132 };
 133
 134 static struct attribute_group stats_attr_group = {
 135         .attrs = no_attrs,
 136         .name = "statistics"
 137 };
 138
 139 static ssize_t id_show(struct kobject *kobj, struct kobj_attribute *attr,
 140                        char *buffer)
 141 {
 142         struct cell *cell = container_of(kobj, struct cell, kobj);
 143
 144         return sprintf(buffer, "%u\n", cell->id);
 145 }
 146
 147 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
 148                           char *buffer)
 149 {
 150         struct cell *cell = container_of(kobj, struct cell, kobj);
 151
 152         switch (jailhouse_call_arg1(JAILHOUSE_HC_CELL_GET_STATE, cell->id)) {
 153         case JAILHOUSE_CELL_RUNNING:
 154                 return sprintf(buffer, "running\n");
 155         case JAILHOUSE_CELL_RUNNING_LOCKED:
 156                 return sprintf(buffer, "running/locked\n");
 157         case JAILHOUSE_CELL_SHUT_DOWN:
 158                 return sprintf(buffer, "shut down\n");
 159         case JAILHOUSE_CELL_FAILED:
 160                 return sprintf(buffer, "failed\n");
 161         default:
 162                 return sprintf(buffer, "invalid\n");
 163         }
 164 }
 165
 166 static ssize_t cpus_assigned_show(struct kobject *kobj,
 167                                   struct kobj_attribute *attr, char *buf)
 168 {
 169         struct cell *cell = container_of(kobj, struct cell, kobj);
 170         int written;
 171
 172 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)
 173         written = scnprintf(buf, PAGE_SIZE, "%*pb\n",
 174                             cpumask_pr_args(&cell->cpus_assigned));
 175 #else
 176         written = cpumask_scnprintf(buf, PAGE_SIZE, &cell->cpus_assigned);
 177         written += scnprintf(buf + written, PAGE_SIZE - written, "\n");
 178 #endif
 179         return written;
 180 }
 181
 182 static ssize_t cpus_failed_show(struct kobject *kobj,
 183                                 struct kobj_attribute *attr, char *buf)
 184 {
 185         struct cell *cell = container_of(kobj, struct cell, kobj);
 186         cpumask_var_t cpus_failed;
 187         unsigned int cpu;
 188         int written;
 189
 190         if (!zalloc_cpumask_var(&cpus_failed, GFP_KERNEL))
 191                 return -ENOMEM;
 192
 193         for_each_cpu(cpu, &cell->cpus_assigned)
 194                 if (jailhouse_call_arg2(JAILHOUSE_HC_CPU_GET_INFO, cpu,
 195                                         JAILHOUSE_CPU_INFO_STATE) ==
 196                     JAILHOUSE_CPU_FAILED)
 197                         cpumask_set_cpu(cpu, cpus_failed);
 198
 199 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)
 200         written = scnprintf(buf, PAGE_SIZE, "%*pb\n",
 201                             cpumask_pr_args(cpus_failed));
 202 #else
 203         written = cpumask_scnprintf(buf, PAGE_SIZE, cpus_failed);
 204         written += scnprintf(buf + written, PAGE_SIZE - written, "\n");
 205 #endif
 206
 207         free_cpumask_var(cpus_failed);
 208
 209         return written;
 210 }
 211
 212 static struct kobj_attribute cell_id_attr = __ATTR_RO(id);
 213 static struct kobj_attribute cell_state_attr = __ATTR_RO(state);
 214 static struct kobj_attribute cell_cpus_assigned_attr =
 215         __ATTR_RO(cpus_assigned);
 216 static struct kobj_attribute cell_cpus_failed_attr = __ATTR_RO(cpus_failed);
 217
 218 static struct attribute *cell_attrs[] = {
 219         &cell_id_attr.attr,
 220         &cell_state_attr.attr,
 221         &cell_cpus_assigned_attr.attr,
 222         &cell_cpus_failed_attr.attr,
 223         NULL,
 224 };
 225
 226 static struct kobj_type cell_type = {
 227         .release = jailhouse_cell_kobj_release,
 228         .sysfs_ops = &kobj_sysfs_ops,
 229         .default_attrs = cell_attrs,
 230 };
 231
 232 int jailhouse_sysfs_cell_create(struct cell *cell, const char *name)
 233 {
 234         int err;
 235
 236         err = kobject_init_and_add(&cell->kobj, &cell_type, cells_dir, "%s",
 237                                    name);
 238         if (err) {
 239                 jailhouse_cell_kobj_release(&cell->kobj);
 240                 return err;
 241         }
 242
 243         err = sysfs_create_group(&cell->kobj, &stats_attr_group);
 244         if (err) {
 245                 kobject_put(&cell->kobj);
 246                 return err;
 247         }
 248
 249         return 0;
 250 }
 251
 252 void jailhouse_sysfs_cell_register(struct cell *cell)
 253 {
 254         kobject_uevent(&cell->kobj, KOBJ_ADD);
 255 }
 256
 257 void jailhouse_sysfs_cell_delete(struct cell *cell)
 258 {
 259         sysfs_remove_group(&cell->kobj, &stats_attr_group);
 260         kobject_put(&cell->kobj);
 261 }
 262
 263 static ssize_t enabled_show(struct device *dev, struct device_attribute *attr,
 264                             char *buffer)
 265 {
 266         return sprintf(buffer, "%d\n", jailhouse_enabled);
 267 }
 268
 269 static ssize_t info_show(struct device *dev, char *buffer, unsigned int type)
 270 {
 271         ssize_t result;
 272         long val = 0;
 273
 274         if (mutex_lock_interruptible(&jailhouse_lock) != 0)
 275                 return -EINTR;
 276
 277         if (jailhouse_enabled)
 278                 val = jailhouse_call_arg1(JAILHOUSE_HC_HYPERVISOR_GET_INFO,
 279                                           type);
 280         if (val >= 0)
 281                 result = sprintf(buffer, "%ld\n", val);
 282         else
 283                 result = val;
 284
 285         mutex_unlock(&jailhouse_lock);
 286         return result;
 287 }
 288
 289 static ssize_t mem_pool_size_show(struct device *dev,
 290                                   struct device_attribute *attr, char *buffer)
 291 {
 292         return info_show(dev, buffer, JAILHOUSE_INFO_MEM_POOL_SIZE);
 293 }
 294
 295 static ssize_t mem_pool_used_show(struct device *dev,
 296                                   struct device_attribute *attr, char *buffer)
 297 {
 298         return info_show(dev, buffer, JAILHOUSE_INFO_MEM_POOL_USED);
 299 }
 300
 301 static ssize_t remap_pool_size_show(struct device *dev,
 302                                     struct device_attribute *attr,
 303                                     char *buffer)
 304 {
 305         return info_show(dev, buffer, JAILHOUSE_INFO_REMAP_POOL_SIZE);
 306 }
 307
 308 static ssize_t remap_pool_used_show(struct device *dev,
 309                                     struct device_attribute *attr,
 310                                     char *buffer)
 311 {
 312         return info_show(dev, buffer, JAILHOUSE_INFO_REMAP_POOL_USED);
 313 }
 314
 315 static DEVICE_ATTR_RO(enabled);
 316 static DEVICE_ATTR_RO(mem_pool_size);
 317 static DEVICE_ATTR_RO(mem_pool_used);
 318 static DEVICE_ATTR_RO(remap_pool_size);
 319 static DEVICE_ATTR_RO(remap_pool_used);
 320
 321 static struct attribute *jailhouse_sysfs_entries[] = {
 322         &dev_attr_enabled.attr,
 323         &dev_attr_mem_pool_size.attr,
 324         &dev_attr_mem_pool_used.attr,
 325         &dev_attr_remap_pool_size.attr,
 326         &dev_attr_remap_pool_used.attr,
 327         NULL
 328 };
 329
 330 static struct attribute_group jailhouse_attribute_group = {
 331         .name = NULL,
 332         .attrs = jailhouse_sysfs_entries,
 333 };
 334
 335 int jailhouse_sysfs_init(struct device *dev)
 336 {
 337         int err;
 338
 339         err = sysfs_create_group(&dev->kobj, &jailhouse_attribute_group);
 340         if (err)
 341                 return err;
 342
 343         cells_dir = kobject_create_and_add("cells", &dev->kobj);
 344         if (!cells_dir) {
 345                 sysfs_remove_group(&dev->kobj, &jailhouse_attribute_group);
 346                 return -ENOMEM;
 347         }
 348
 349         return 0;
 350 }
 351
 352 void jailhouse_sysfs_exit(struct device *dev)
 353 {
 354         kobject_put(cells_dir);
 355         sysfs_remove_group(&dev->kobj, &jailhouse_attribute_group);
 356 }