drivers/xen/sys-hypervisor.c

   1 /*
   2  *  copyright (c) 2006 IBM Corporation
   3  *  Authored by: Mike D. Day <ncmike@us.ibm.com>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License version 2 as
   7  *  published by the Free Software Foundation.
   8  */
   9
  10 #include <linux/slab.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/kobject.h>
  14 #include <linux/err.h>
  15
  16 #include <asm/xen/hypervisor.h>
  17 #include <asm/xen/hypercall.h>
  18
  19 #include <xen/xen.h>
  20 #include <xen/xenbus.h>
  21 #include <xen/interface/xen.h>
  22 #include <xen/interface/version.h>
  23
  24 #define HYPERVISOR_ATTR_RO(_name) \
  25 static struct hyp_sysfs_attr  _name##_attr = __ATTR_RO(_name)
  26
  27 #define HYPERVISOR_ATTR_RW(_name) \
  28 static struct hyp_sysfs_attr _name##_attr = \
  29         __ATTR(_name, 0644, _name##_show, _name##_store)
  30
  31 struct hyp_sysfs_attr {
  32         struct attribute attr;
  33         ssize_t (*show)(struct hyp_sysfs_attr *, char *);
  34         ssize_t (*store)(struct hyp_sysfs_attr *, const char *, size_t);
  35         void *hyp_attr_data;
  36 };
  37
  38 static ssize_t type_show(struct hyp_sysfs_attr *attr, char *buffer)
  39 {
  40         return sprintf(buffer, "xen\n");
  41 }
  42
  43 HYPERVISOR_ATTR_RO(type);
  44
  45 static int __init xen_sysfs_type_init(void)
  46 {
  47         return sysfs_create_file(hypervisor_kobj, &type_attr.attr);
  48 }
  49
  50 static void xen_sysfs_type_destroy(void)
  51 {
  52         sysfs_remove_file(hypervisor_kobj, &type_attr.attr);
  53 }
  54
  55 /* xen version attributes */
  56 static ssize_t major_show(struct hyp_sysfs_attr *attr, char *buffer)
  57 {
  58         int version = HYPERVISOR_xen_version(XENVER_version, NULL);
  59         if (version)
  60                 return sprintf(buffer, "%d\n", version >> 16);
  61         return -ENODEV;
  62 }
  63
  64 HYPERVISOR_ATTR_RO(major);
  65
  66 static ssize_t minor_show(struct hyp_sysfs_attr *attr, char *buffer)
  67 {
  68         int version = HYPERVISOR_xen_version(XENVER_version, NULL);
  69         if (version)
  70                 return sprintf(buffer, "%d\n", version & 0xff);
  71         return -ENODEV;
  72 }
  73
  74 HYPERVISOR_ATTR_RO(minor);
  75
  76 static ssize_t extra_show(struct hyp_sysfs_attr *attr, char *buffer)
  77 {
  78         int ret = -ENOMEM;
  79         char *extra;
  80
  81         extra = kmalloc(XEN_EXTRAVERSION_LEN, GFP_KERNEL);
  82         if (extra) {
  83                 ret = HYPERVISOR_xen_version(XENVER_extraversion, extra);
  84                 if (!ret)
  85                         ret = sprintf(buffer, "%s\n", extra);
  86                 kfree(extra);
  87         }
  88
  89         return ret;
  90 }
  91
  92 HYPERVISOR_ATTR_RO(extra);
  93
  94 static struct attribute *version_attrs[] = {
  95         &major_attr.attr,
  96         &minor_attr.attr,
  97         &extra_attr.attr,
  98         NULL
  99 };
 100
 101 static const struct attribute_group version_group = {
 102         .name = "version",
 103         .attrs = version_attrs,
 104 };
 105
 106 static int __init xen_sysfs_version_init(void)
 107 {
 108         return sysfs_create_group(hypervisor_kobj, &version_group);
 109 }
 110
 111 static void xen_sysfs_version_destroy(void)
 112 {
 113         sysfs_remove_group(hypervisor_kobj, &version_group);
 114 }
 115
 116 /* UUID */
 117
 118 static ssize_t uuid_show_fallback(struct hyp_sysfs_attr *attr, char *buffer)
 119 {
 120         char *vm, *val;
 121         int ret;
 122         extern int xenstored_ready;
 123
 124         if (!xenstored_ready)
 125                 return -EBUSY;
 126
 127         vm = xenbus_read(XBT_NIL, "vm", "", NULL);
 128         if (IS_ERR(vm))
 129                 return PTR_ERR(vm);
 130         val = xenbus_read(XBT_NIL, vm, "uuid", NULL);
 131         kfree(vm);
 132         if (IS_ERR(val))
 133                 return PTR_ERR(val);
 134         ret = sprintf(buffer, "%s\n", val);
 135         kfree(val);
 136         return ret;
 137 }
 138
 139 static ssize_t uuid_show(struct hyp_sysfs_attr *attr, char *buffer)
 140 {
 141         xen_domain_handle_t uuid;
 142         int ret;
 143         ret = HYPERVISOR_xen_version(XENVER_guest_handle, uuid);
 144         if (ret)
 145                 return uuid_show_fallback(attr, buffer);
 146         ret = sprintf(buffer, "%pU\n", uuid);
 147         return ret;
 148 }
 149
 150 HYPERVISOR_ATTR_RO(uuid);
 151
 152 static int __init xen_sysfs_uuid_init(void)
 153 {
 154         return sysfs_create_file(hypervisor_kobj, &uuid_attr.attr);
 155 }
 156
 157 static void xen_sysfs_uuid_destroy(void)
 158 {
 159         sysfs_remove_file(hypervisor_kobj, &uuid_attr.attr);
 160 }
 161
 162 /* xen compilation attributes */
 163
 164 static ssize_t compiler_show(struct hyp_sysfs_attr *attr, char *buffer)
 165 {
 166         int ret = -ENOMEM;
 167         struct xen_compile_info *info;
 168
 169         info = kmalloc(sizeof(struct xen_compile_info), GFP_KERNEL);
 170         if (info) {
 171                 ret = HYPERVISOR_xen_version(XENVER_compile_info, info);
 172                 if (!ret)
 173                         ret = sprintf(buffer, "%s\n", info->compiler);
 174                 kfree(info);
 175         }
 176
 177         return ret;
 178 }
 179
 180 HYPERVISOR_ATTR_RO(compiler);
 181
 182 static ssize_t compiled_by_show(struct hyp_sysfs_attr *attr, char *buffer)
 183 {
 184         int ret = -ENOMEM;
 185         struct xen_compile_info *info;
 186
 187         info = kmalloc(sizeof(struct xen_compile_info), GFP_KERNEL);
 188         if (info) {
 189                 ret = HYPERVISOR_xen_version(XENVER_compile_info, info);
 190                 if (!ret)
 191                         ret = sprintf(buffer, "%s\n", info->compile_by);
 192                 kfree(info);
 193         }
 194
 195         return ret;
 196 }
 197
 198 HYPERVISOR_ATTR_RO(compiled_by);
 199
 200 static ssize_t compile_date_show(struct hyp_sysfs_attr *attr, char *buffer)
 201 {
 202         int ret = -ENOMEM;
 203         struct xen_compile_info *info;
 204
 205         info = kmalloc(sizeof(struct xen_compile_info), GFP_KERNEL);
 206         if (info) {
 207                 ret = HYPERVISOR_xen_version(XENVER_compile_info, info);
 208                 if (!ret)
 209                         ret = sprintf(buffer, "%s\n", info->compile_date);
 210                 kfree(info);
 211         }
 212
 213         return ret;
 214 }
 215
 216 HYPERVISOR_ATTR_RO(compile_date);
 217
 218 static struct attribute *xen_compile_attrs[] = {
 219         &compiler_attr.attr,
 220         &compiled_by_attr.attr,
 221         &compile_date_attr.attr,
 222         NULL
 223 };
 224
 225 static const struct attribute_group xen_compilation_group = {
 226         .name = "compilation",
 227         .attrs = xen_compile_attrs,
 228 };
 229
 230 static int __init xen_compilation_init(void)
 231 {
 232         return sysfs_create_group(hypervisor_kobj, &xen_compilation_group);
 233 }
 234
 235 static void xen_compilation_destroy(void)
 236 {
 237         sysfs_remove_group(hypervisor_kobj, &xen_compilation_group);
 238 }
 239
 240 /* xen properties info */
 241
 242 static ssize_t capabilities_show(struct hyp_sysfs_attr *attr, char *buffer)
 243 {
 244         int ret = -ENOMEM;
 245         char *caps;
 246
 247         caps = kmalloc(XEN_CAPABILITIES_INFO_LEN, GFP_KERNEL);
 248         if (caps) {
 249                 ret = HYPERVISOR_xen_version(XENVER_capabilities, caps);
 250                 if (!ret)
 251                         ret = sprintf(buffer, "%s\n", caps);
 252                 kfree(caps);
 253         }
 254
 255         return ret;
 256 }
 257
 258 HYPERVISOR_ATTR_RO(capabilities);
 259
 260 static ssize_t changeset_show(struct hyp_sysfs_attr *attr, char *buffer)
 261 {
 262         int ret = -ENOMEM;
 263         char *cset;
 264
 265         cset = kmalloc(XEN_CHANGESET_INFO_LEN, GFP_KERNEL);
 266         if (cset) {
 267                 ret = HYPERVISOR_xen_version(XENVER_changeset, cset);
 268                 if (!ret)
 269                         ret = sprintf(buffer, "%s\n", cset);
 270                 kfree(cset);
 271         }
 272
 273         return ret;
 274 }
 275
 276 HYPERVISOR_ATTR_RO(changeset);
 277
 278 static ssize_t virtual_start_show(struct hyp_sysfs_attr *attr, char *buffer)
 279 {
 280         int ret = -ENOMEM;
 281         struct xen_platform_parameters *parms;
 282
 283         parms = kmalloc(sizeof(struct xen_platform_parameters), GFP_KERNEL);
 284         if (parms) {
 285                 ret = HYPERVISOR_xen_version(XENVER_platform_parameters,
 286                                              parms);
 287                 if (!ret)
 288                         ret = sprintf(buffer, "%lx\n", parms->virt_start);
 289                 kfree(parms);
 290         }
 291
 292         return ret;
 293 }
 294
 295 HYPERVISOR_ATTR_RO(virtual_start);
 296
 297 static ssize_t pagesize_show(struct hyp_sysfs_attr *attr, char *buffer)
 298 {
 299         int ret;
 300
 301         ret = HYPERVISOR_xen_version(XENVER_pagesize, NULL);
 302         if (ret > 0)
 303                 ret = sprintf(buffer, "%x\n", ret);
 304
 305         return ret;
 306 }
 307
 308 HYPERVISOR_ATTR_RO(pagesize);
 309
 310 static ssize_t xen_feature_show(int index, char *buffer)
 311 {
 312         ssize_t ret;
 313         struct xen_feature_info info;
 314
 315         info.submap_idx = index;
 316         ret = HYPERVISOR_xen_version(XENVER_get_features, &info);
 317         if (!ret)
 318                 ret = sprintf(buffer, "%08x", info.submap);
 319
 320         return ret;
 321 }
 322
 323 static ssize_t features_show(struct hyp_sysfs_attr *attr, char *buffer)
 324 {
 325         ssize_t len;
 326         int i;
 327
 328         len = 0;
 329         for (i = XENFEAT_NR_SUBMAPS-1; i >= 0; i--) {
 330                 int ret = xen_feature_show(i, buffer + len);
 331                 if (ret < 0) {
 332                         if (len == 0)
 333                                 len = ret;
 334                         break;
 335                 }
 336                 len += ret;
 337         }
 338         if (len > 0)
 339                 buffer[len++] = '\n';
 340
 341         return len;
 342 }
 343
 344 HYPERVISOR_ATTR_RO(features);
 345
 346 static struct attribute *xen_properties_attrs[] = {
 347         &capabilities_attr.attr,
 348         &changeset_attr.attr,
 349         &virtual_start_attr.attr,
 350         &pagesize_attr.attr,
 351         &features_attr.attr,
 352         NULL
 353 };
 354
 355 static const struct attribute_group xen_properties_group = {
 356         .name = "properties",
 357         .attrs = xen_properties_attrs,
 358 };
 359
 360 static int __init xen_properties_init(void)
 361 {
 362         return sysfs_create_group(hypervisor_kobj, &xen_properties_group);
 363 }
 364
 365 static void xen_properties_destroy(void)
 366 {
 367         sysfs_remove_group(hypervisor_kobj, &xen_properties_group);
 368 }
 369
 370 static int __init hyper_sysfs_init(void)
 371 {
 372         int ret;
 373
 374         if (!xen_domain())
 375                 return -ENODEV;
 376
 377         ret = xen_sysfs_type_init();
 378         if (ret)
 379                 goto out;
 380         ret = xen_sysfs_version_init();
 381         if (ret)
 382                 goto version_out;
 383         ret = xen_compilation_init();
 384         if (ret)
 385                 goto comp_out;
 386         ret = xen_sysfs_uuid_init();
 387         if (ret)
 388                 goto uuid_out;
 389         ret = xen_properties_init();
 390         if (ret)
 391                 goto prop_out;
 392
 393         goto out;
 394
 395 prop_out:
 396         xen_sysfs_uuid_destroy();
 397 uuid_out:
 398         xen_compilation_destroy();
 399 comp_out:
 400         xen_sysfs_version_destroy();
 401 version_out:
 402         xen_sysfs_type_destroy();
 403 out:
 404         return ret;
 405 }
 406
 407 static void __exit hyper_sysfs_exit(void)
 408 {
 409         xen_properties_destroy();
 410         xen_compilation_destroy();
 411         xen_sysfs_uuid_destroy();
 412         xen_sysfs_version_destroy();
 413         xen_sysfs_type_destroy();
 414
 415 }
 416 module_init(hyper_sysfs_init);
 417 module_exit(hyper_sysfs_exit);
 418
 419 static ssize_t hyp_sysfs_show(struct kobject *kobj,
 420                               struct attribute *attr,
 421                               char *buffer)
 422 {
 423         struct hyp_sysfs_attr *hyp_attr;
 424         hyp_attr = container_of(attr, struct hyp_sysfs_attr, attr);
 425         if (hyp_attr->show)
 426                 return hyp_attr->show(hyp_attr, buffer);
 427         return 0;
 428 }
 429
 430 static ssize_t hyp_sysfs_store(struct kobject *kobj,
 431                                struct attribute *attr,
 432                                const char *buffer,
 433                                size_t len)
 434 {
 435         struct hyp_sysfs_attr *hyp_attr;
 436         hyp_attr = container_of(attr, struct hyp_sysfs_attr, attr);
 437         if (hyp_attr->store)
 438                 return hyp_attr->store(hyp_attr, buffer, len);
 439         return 0;
 440 }
 441
 442 static const struct sysfs_ops hyp_sysfs_ops = {
 443         .show = hyp_sysfs_show,
 444         .store = hyp_sysfs_store,
 445 };
 446
 447 static struct kobj_type hyp_sysfs_kobj_type = {
 448         .sysfs_ops = &hyp_sysfs_ops,
 449 };
 450
 451 static int __init hypervisor_subsys_init(void)
 452 {
 453         if (!xen_domain())
 454                 return -ENODEV;
 455
 456         hypervisor_kobj->ktype = &hyp_sysfs_kobj_type;
 457         return 0;
 458 }
 459 device_initcall(hypervisor_subsys_init);