drivers/xen/pcpu.c

   1 /******************************************************************************
   2  * pcpu.c
   3  * Management physical cpu in dom0, get pcpu info and provide sys interface
   4  *
   5  * Copyright (c) 2012 Intel Corporation
   6  * Author: Liu, Jinsong <jinsong.liu@intel.com>
   7  * Author: Jiang, Yunhong <yunhong.jiang@intel.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation; or, when distributed
  12  * separately from the Linux kernel or incorporated into other
  13  * software packages, subject to the following license:
  14  *
  15  * Permission is hereby granted, free of charge, to any person obtaining a copy
  16  * of this source file (the "Software"), to deal in the Software without
  17  * restriction, including without limitation the rights to use, copy, modify,
  18  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  19  * and to permit persons to whom the Software is furnished to do so, subject to
  20  * the following conditions:
  21  *
  22  * The above copyright notice and this permission notice shall be included in
  23  * all copies or substantial portions of the Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  28  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  29  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  30  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  31  * IN THE SOFTWARE.
  32  */
  33
  34 #define pr_fmt(fmt) "xen_cpu: " fmt
  35
  36 #include <linux/interrupt.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/cpu.h>
  39 #include <linux/stat.h>
  40 #include <linux/capability.h>
  41
  42 #include <xen/xen.h>
  43 #include <xen/acpi.h>
  44 #include <xen/xenbus.h>
  45 #include <xen/events.h>
  46 #include <xen/interface/platform.h>
  47 #include <asm/xen/hypervisor.h>
  48 #include <asm/xen/hypercall.h>
  49
  50
  51 /*
  52  * @cpu_id: Xen physical cpu logic number
  53  * @flags: Xen physical cpu status flag
  54  * - XEN_PCPU_FLAGS_ONLINE: cpu is online
  55  * - XEN_PCPU_FLAGS_INVALID: cpu is not present
  56  */
  57 struct pcpu {
  58         struct list_head list;
  59         struct device dev;
  60         uint32_t cpu_id;
  61         uint32_t flags;
  62 };
  63
  64 static struct bus_type xen_pcpu_subsys = {
  65         .name = "xen_cpu",
  66         .dev_name = "xen_cpu",
  67 };
  68
  69 static DEFINE_MUTEX(xen_pcpu_lock);
  70
  71 static LIST_HEAD(xen_pcpus);
  72
  73 static int xen_pcpu_down(uint32_t cpu_id)
  74 {
  75         struct xen_platform_op op = {
  76                 .cmd                    = XENPF_cpu_offline,
  77                 .interface_version      = XENPF_INTERFACE_VERSION,
  78                 .u.cpu_ol.cpuid         = cpu_id,
  79         };
  80
  81         return HYPERVISOR_dom0_op(&op);
  82 }
  83
  84 static int xen_pcpu_up(uint32_t cpu_id)
  85 {
  86         struct xen_platform_op op = {
  87                 .cmd                    = XENPF_cpu_online,
  88                 .interface_version      = XENPF_INTERFACE_VERSION,
  89                 .u.cpu_ol.cpuid         = cpu_id,
  90         };
  91
  92         return HYPERVISOR_dom0_op(&op);
  93 }
  94
  95 static ssize_t show_online(struct device *dev,
  96                            struct device_attribute *attr,
  97                            char *buf)
  98 {
  99         struct pcpu *cpu = container_of(dev, struct pcpu, dev);
 100
 101         return sprintf(buf, "%u\n", !!(cpu->flags & XEN_PCPU_FLAGS_ONLINE));
 102 }
 103
 104 static ssize_t __ref store_online(struct device *dev,
 105                                   struct device_attribute *attr,
 106                                   const char *buf, size_t count)
 107 {
 108         struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
 109         unsigned long long val;
 110         ssize_t ret;
 111
 112         if (!capable(CAP_SYS_ADMIN))
 113                 return -EPERM;
 114
 115         if (kstrtoull(buf, 0, &val) < 0)
 116                 return -EINVAL;
 117
 118         switch (val) {
 119         case 0:
 120                 ret = xen_pcpu_down(pcpu->cpu_id);
 121                 break;
 122         case 1:
 123                 ret = xen_pcpu_up(pcpu->cpu_id);
 124                 break;
 125         default:
 126                 ret = -EINVAL;
 127         }
 128
 129         if (ret >= 0)
 130                 ret = count;
 131         return ret;
 132 }
 133 static DEVICE_ATTR(online, S_IRUGO | S_IWUSR, show_online, store_online);
 134
 135 static bool xen_pcpu_online(uint32_t flags)
 136 {
 137         return !!(flags & XEN_PCPU_FLAGS_ONLINE);
 138 }
 139
 140 static void pcpu_online_status(struct xenpf_pcpuinfo *info,
 141                                struct pcpu *pcpu)
 142 {
 143         if (xen_pcpu_online(info->flags) &&
 144            !xen_pcpu_online(pcpu->flags)) {
 145                 /* the pcpu is onlined */
 146                 pcpu->flags |= XEN_PCPU_FLAGS_ONLINE;
 147                 kobject_uevent(&pcpu->dev.kobj, KOBJ_ONLINE);
 148         } else if (!xen_pcpu_online(info->flags) &&
 149                     xen_pcpu_online(pcpu->flags)) {
 150                 /* The pcpu is offlined */
 151                 pcpu->flags &= ~XEN_PCPU_FLAGS_ONLINE;
 152                 kobject_uevent(&pcpu->dev.kobj, KOBJ_OFFLINE);
 153         }
 154 }
 155
 156 static struct pcpu *get_pcpu(uint32_t cpu_id)
 157 {
 158         struct pcpu *pcpu;
 159
 160         list_for_each_entry(pcpu, &xen_pcpus, list) {
 161                 if (pcpu->cpu_id == cpu_id)
 162                         return pcpu;
 163         }
 164
 165         return NULL;
 166 }
 167
 168 static void pcpu_release(struct device *dev)
 169 {
 170         struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
 171
 172         list_del(&pcpu->list);
 173         kfree(pcpu);
 174 }
 175
 176 static void unregister_and_remove_pcpu(struct pcpu *pcpu)
 177 {
 178         struct device *dev;
 179
 180         if (!pcpu)
 181                 return;
 182
 183         dev = &pcpu->dev;
 184         if (dev->id)
 185                 device_remove_file(dev, &dev_attr_online);
 186
 187         /* pcpu remove would be implicitly done */
 188         device_unregister(dev);
 189 }
 190
 191 static int register_pcpu(struct pcpu *pcpu)
 192 {
 193         struct device *dev;
 194         int err = -EINVAL;
 195
 196         if (!pcpu)
 197                 return err;
 198
 199         dev = &pcpu->dev;
 200         dev->bus = &xen_pcpu_subsys;
 201         dev->id = pcpu->cpu_id;
 202         dev->release = pcpu_release;
 203
 204         err = device_register(dev);
 205         if (err) {
 206                 pcpu_release(dev);
 207                 return err;
 208         }
 209
 210         /*
 211          * Xen never offline cpu0 due to several restrictions
 212          * and assumptions. This basically doesn't add a sys control
 213          * to user, one cannot attempt to offline BSP.
 214          */
 215         if (dev->id) {
 216                 err = device_create_file(dev, &dev_attr_online);
 217                 if (err) {
 218                         device_unregister(dev);
 219                         return err;
 220                 }
 221         }
 222
 223         return 0;
 224 }
 225
 226 static struct pcpu *create_and_register_pcpu(struct xenpf_pcpuinfo *info)
 227 {
 228         struct pcpu *pcpu;
 229         int err;
 230
 231         if (info->flags & XEN_PCPU_FLAGS_INVALID)
 232                 return ERR_PTR(-ENODEV);
 233
 234         pcpu = kzalloc(sizeof(struct pcpu), GFP_KERNEL);
 235         if (!pcpu)
 236                 return ERR_PTR(-ENOMEM);
 237
 238         INIT_LIST_HEAD(&pcpu->list);
 239         pcpu->cpu_id = info->xen_cpuid;
 240         pcpu->flags = info->flags;
 241
 242         /* Need hold on xen_pcpu_lock before pcpu list manipulations */
 243         list_add_tail(&pcpu->list, &xen_pcpus);
 244
 245         err = register_pcpu(pcpu);
 246         if (err) {
 247                 pr_warn("Failed to register pcpu%u\n", info->xen_cpuid);
 248                 return ERR_PTR(-ENOENT);
 249         }
 250
 251         return pcpu;
 252 }
 253
 254 /*
 255  * Caller should hold the xen_pcpu_lock
 256  */
 257 static int sync_pcpu(uint32_t cpu, uint32_t *max_cpu)
 258 {
 259         int ret;
 260         struct pcpu *pcpu = NULL;
 261         struct xenpf_pcpuinfo *info;
 262         struct xen_platform_op op = {
 263                 .cmd                   = XENPF_get_cpuinfo,
 264                 .interface_version     = XENPF_INTERFACE_VERSION,
 265                 .u.pcpu_info.xen_cpuid = cpu,
 266         };
 267
 268         ret = HYPERVISOR_dom0_op(&op);
 269         if (ret)
 270                 return ret;
 271
 272         info = &op.u.pcpu_info;
 273         if (max_cpu)
 274                 *max_cpu = info->max_present;
 275
 276         pcpu = get_pcpu(cpu);
 277
 278         /*
 279          * Only those at cpu present map has its sys interface.
 280          */
 281         if (info->flags & XEN_PCPU_FLAGS_INVALID) {
 282                 unregister_and_remove_pcpu(pcpu);
 283                 return 0;
 284         }
 285
 286         if (!pcpu) {
 287                 pcpu = create_and_register_pcpu(info);
 288                 if (IS_ERR_OR_NULL(pcpu))
 289                         return -ENODEV;
 290         } else
 291                 pcpu_online_status(info, pcpu);
 292
 293         return 0;
 294 }
 295
 296 /*
 297  * Sync dom0's pcpu information with xen hypervisor's
 298  */
 299 static int xen_sync_pcpus(void)
 300 {
 301         /*
 302          * Boot cpu always have cpu_id 0 in xen
 303          */
 304         uint32_t cpu = 0, max_cpu = 0;
 305         int err = 0;
 306         struct pcpu *pcpu, *tmp;
 307
 308         mutex_lock(&xen_pcpu_lock);
 309
 310         while (!err && (cpu <= max_cpu)) {
 311                 err = sync_pcpu(cpu, &max_cpu);
 312                 cpu++;
 313         }
 314
 315         if (err)
 316                 list_for_each_entry_safe(pcpu, tmp, &xen_pcpus, list)
 317                         unregister_and_remove_pcpu(pcpu);
 318
 319         mutex_unlock(&xen_pcpu_lock);
 320
 321         return err;
 322 }
 323
 324 static void xen_pcpu_work_fn(struct work_struct *work)
 325 {
 326         xen_sync_pcpus();
 327 }
 328 static DECLARE_WORK(xen_pcpu_work, xen_pcpu_work_fn);
 329
 330 static irqreturn_t xen_pcpu_interrupt(int irq, void *dev_id)
 331 {
 332         schedule_work(&xen_pcpu_work);
 333         return IRQ_HANDLED;
 334 }
 335
 336 /* Sync with Xen hypervisor after cpu hotadded */
 337 void xen_pcpu_hotplug_sync(void)
 338 {
 339         schedule_work(&xen_pcpu_work);
 340 }
 341 EXPORT_SYMBOL_GPL(xen_pcpu_hotplug_sync);
 342
 343 /*
 344  * For hypervisor presented cpu, return logic cpu id;
 345  * For hypervisor non-presented cpu, return -ENODEV.
 346  */
 347 int xen_pcpu_id(uint32_t acpi_id)
 348 {
 349         int cpu_id = 0, max_id = 0;
 350         struct xen_platform_op op;
 351
 352         op.cmd = XENPF_get_cpuinfo;
 353         while (cpu_id <= max_id) {
 354                 op.u.pcpu_info.xen_cpuid = cpu_id;
 355                 if (HYPERVISOR_dom0_op(&op)) {
 356                         cpu_id++;
 357                         continue;
 358                 }
 359
 360                 if (acpi_id == op.u.pcpu_info.acpi_id)
 361                         return cpu_id;
 362                 if (op.u.pcpu_info.max_present > max_id)
 363                         max_id = op.u.pcpu_info.max_present;
 364                 cpu_id++;
 365         }
 366
 367         return -ENODEV;
 368 }
 369 EXPORT_SYMBOL_GPL(xen_pcpu_id);
 370
 371 static int __init xen_pcpu_init(void)
 372 {
 373         int irq, ret;
 374
 375         if (!xen_initial_domain())
 376                 return -ENODEV;
 377
 378         irq = bind_virq_to_irqhandler(VIRQ_PCPU_STATE, 0,
 379                                       xen_pcpu_interrupt, 0,
 380                                       "xen-pcpu", NULL);
 381         if (irq < 0) {
 382                 pr_warn("Failed to bind pcpu virq\n");
 383                 return irq;
 384         }
 385
 386         ret = subsys_system_register(&xen_pcpu_subsys, NULL);
 387         if (ret) {
 388                 pr_warn("Failed to register pcpu subsys\n");
 389                 goto err1;
 390         }
 391
 392         ret = xen_sync_pcpus();
 393         if (ret) {
 394                 pr_warn("Failed to sync pcpu info\n");
 395                 goto err2;
 396         }
 397
 398         return 0;
 399
 400 err2:
 401         bus_unregister(&xen_pcpu_subsys);
 402 err1:
 403         unbind_from_irqhandler(irq, NULL);
 404         return ret;
 405 }
 406 arch_initcall(xen_pcpu_init);