sys/dev/xen/control/control.c

   1 /*-
   2  * Copyright (c) 2010 Justin T. Gibbs, Spectra Logic Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    substantially similar to the "NO WARRANTY" disclaimer below
  13  *    ("Disclaimer") and any redistribution must be conditioned upon
  14  *    including a substantially similar Disclaimer requirement for further
  15  *    binary redistribution.
  16  *
  17  * NO WARRANTY
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGES.
  29  */
  30
  31 /*-
  32  * PV suspend/resume support:
  33  *
  34  * Copyright (c) 2004 Christian Limpach.
  35  * Copyright (c) 2004-2006,2008 Kip Macy
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by Christian Limpach.
  49  * 4. The name of the author may not be used to endorse or promote products
  50  *    derived from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  53  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  54  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  55  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  56  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  57  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  58  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  59  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  61  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62  */
  63
  64 /*-
  65  * HVM suspend/resume support:
  66  *
  67  * Copyright (c) 2008 Citrix Systems, Inc.
  68  * All rights reserved.
  69  *
  70  * Redistribution and use in source and binary forms, with or without
  71  * modification, are permitted provided that the following conditions
  72  * are met:
  73  * 1. Redistributions of source code must retain the above copyright
  74  *    notice, this list of conditions and the following disclaimer.
  75  * 2. Redistributions in binary form must reproduce the above copyright
  76  *    notice, this list of conditions and the following disclaimer in the
  77  *    documentation and/or other materials provided with the distribution.
  78  *
  79  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  80  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  81  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  82  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  83  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  84  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  85  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  86  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  87  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  88  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  89  * SUCH DAMAGE.
  90  */
  91 #include <sys/cdefs.h>
  92 __FBSDID("$FreeBSD$");
  93
  94 /**
  95  * \file control.c
  96  *
  97  * \brief Device driver to repond to control domain events that impact
  98  *        this VM.
  99  */
 100
 101 #include <sys/param.h>
 102 #include <sys/systm.h>
 103 #include <sys/kernel.h>
 104 #include <sys/malloc.h>
 105
 106 #include <sys/bio.h>
 107 #include <sys/bus.h>
 108 #include <sys/conf.h>
 109 #include <sys/disk.h>
 110 #include <sys/fcntl.h>
 111 #include <sys/filedesc.h>
 112 #include <sys/kdb.h>
 113 #include <sys/module.h>
 114 #include <sys/namei.h>
 115 #include <sys/proc.h>
 116 #include <sys/reboot.h>
 117 #include <sys/rman.h>
 118 #include <sys/taskqueue.h>
 119 #include <sys/types.h>
 120 #include <sys/vnode.h>
 121
 122 #ifndef XENHVM
 123 #include <sys/sched.h>
 124 #include <sys/smp.h>
 125 #endif
 126
 127
 128 #include <geom/geom.h>
 129
 130 #include <machine/_inttypes.h>
 131 #include <machine/xen/xen-os.h>
 132
 133 #include <vm/vm.h>
 134 #include <vm/vm_extern.h>
 135 #include <vm/vm_kern.h>
 136
 137 #include <xen/blkif.h>
 138 #include <xen/evtchn.h>
 139 #include <xen/gnttab.h>
 140 #include <xen/xen_intr.h>
 141
 142 #include <xen/interface/event_channel.h>
 143 #include <xen/interface/grant_table.h>
 144
 145 #include <xen/xenbus/xenbusvar.h>
 146
 147 #define NUM_ELEMENTS(x) (sizeof(x) / sizeof(*(x)))
 148
 149 /*--------------------------- Forward Declarations --------------------------*/
 150 /** Function signature for shutdown event handlers. */
 151 typedef void (xctrl_shutdown_handler_t)(void);
 152
 153 static xctrl_shutdown_handler_t xctrl_poweroff;
 154 static xctrl_shutdown_handler_t xctrl_reboot;
 155 static xctrl_shutdown_handler_t xctrl_suspend;
 156 static xctrl_shutdown_handler_t xctrl_crash;
 157 static xctrl_shutdown_handler_t xctrl_halt;
 158
 159 /*-------------------------- Private Data Structures -------------------------*/
 160 /** Element type for lookup table of event name to handler. */
 161 struct xctrl_shutdown_reason {
 162         const char               *name;
 163         xctrl_shutdown_handler_t *handler;
 164 };
 165
 166 /** Lookup table for shutdown event name to handler. */
 167 static struct xctrl_shutdown_reason xctrl_shutdown_reasons[] = {
 168         { "poweroff", xctrl_poweroff },
 169         { "reboot",   xctrl_reboot   },
 170         { "suspend",  xctrl_suspend  },
 171         { "crash",    xctrl_crash    },
 172         { "halt",     xctrl_halt     },
 173 };
 174
 175 struct xctrl_softc {
 176
 177         /** Must be first */
 178         struct xs_watch    xctrl_watch;
 179 };
 180
 181 /*------------------------------ Event Handlers ------------------------------*/
 182 static void
 183 xctrl_poweroff()
 184 {
 185         shutdown_nice(RB_POWEROFF|RB_HALT);
 186 }
 187
 188 static void
 189 xctrl_reboot()
 190 {
 191         shutdown_nice(0);
 192 }
 193
 194 #ifndef XENHVM
 195 extern void xencons_suspend(void);
 196 extern void xencons_resume(void);
 197
 198 /* Full PV mode suspension. */
 199 static void
 200 xctrl_suspend()
 201 {
 202         int i, j, k, fpp;
 203         unsigned long max_pfn, start_info_mfn;
 204
 205 #ifdef SMP
 206         cpumask_t map;
 207         /*
 208          * Bind us to CPU 0 and stop any other VCPUs.
 209          */
 210         thread_lock(curthread);
 211         sched_bind(curthread, 0);
 212         thread_unlock(curthread);
 213         KASSERT(PCPU_GET(cpuid) == 0, ("xen_suspend: not running on cpu 0"));
 214
 215         map = PCPU_GET(other_cpus) & ~stopped_cpus;
 216         if (map)
 217                 stop_cpus(map);
 218 #endif
 219
 220         if (DEVICE_SUSPEND(root_bus) != 0) {
 221                 printf("xen_suspend: device_suspend failed\n");
 222 #ifdef SMP
 223                 if (map)
 224                         restart_cpus(map);
 225 #endif
 226                 return;
 227         }
 228
 229         local_irq_disable();
 230
 231         xencons_suspend();
 232         gnttab_suspend();
 233
 234         max_pfn = HYPERVISOR_shared_info->arch.max_pfn;
 235
 236         void *shared_info = HYPERVISOR_shared_info;
 237         HYPERVISOR_shared_info = NULL;
 238         pmap_kremove((vm_offset_t) shared_info);
 239         PT_UPDATES_FLUSH();
 240
 241         xen_start_info->store_mfn = MFNTOPFN(xen_start_info->store_mfn);
 242         xen_start_info->console.domU.mfn = MFNTOPFN(xen_start_info->console.domU.mfn);
 243
 244         /*
 245          * We'll stop somewhere inside this hypercall. When it returns,
 246          * we'll start resuming after the restore.
 247          */
 248         start_info_mfn = VTOMFN(xen_start_info);
 249         pmap_suspend();
 250         HYPERVISOR_suspend(start_info_mfn);
 251         pmap_resume();
 252
 253         pmap_kenter_ma((vm_offset_t) shared_info, xen_start_info->shared_info);
 254         HYPERVISOR_shared_info = shared_info;
 255
 256         HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list =
 257                 VTOMFN(xen_pfn_to_mfn_frame_list_list);
 258
 259         fpp = PAGE_SIZE/sizeof(unsigned long);
 260         for (i = 0, j = 0, k = -1; i < max_pfn; i += fpp, j++) {
 261                 if ((j % fpp) == 0) {
 262                         k++;
 263                         xen_pfn_to_mfn_frame_list_list[k] =
 264                                 VTOMFN(xen_pfn_to_mfn_frame_list[k]);
 265                         j = 0;
 266                 }
 267                 xen_pfn_to_mfn_frame_list[k][j] =
 268                         VTOMFN(&xen_phys_machine[i]);
 269         }
 270         HYPERVISOR_shared_info->arch.max_pfn = max_pfn;
 271
 272         gnttab_resume();
 273         irq_resume();
 274         local_irq_enable();
 275         xencons_resume();
 276
 277 #ifdef CONFIG_SMP
 278         for_each_cpu(i)
 279                 vcpu_prepare(i);
 280
 281 #endif
 282         /*
 283          * Only resume xenbus /after/ we've prepared our VCPUs; otherwise
 284          * the VCPU hotplug callback can race with our vcpu_prepare
 285          */
 286         DEVICE_RESUME(root_bus);
 287
 288 #ifdef SMP
 289         thread_lock(curthread);
 290         sched_unbind(curthread);
 291         thread_unlock(curthread);
 292         if (map)
 293                 restart_cpus(map);
 294 #endif
 295 }
 296
 297 static void
 298 xen_pv_shutdown_final(void *arg, int howto)
 299 {
 300         /*
 301          * Inform the hypervisor that shutdown is complete.
 302          * This is not necessary in HVM domains since Xen
 303          * emulates ACPI in that mode and FreeBSD's ACPI
 304          * support will request this transition.
 305          */
 306         if (howto & (RB_HALT | RB_POWEROFF))
 307                 HYPERVISOR_shutdown(SHUTDOWN_poweroff);
 308         else
 309                 HYPERVISOR_shutdown(SHUTDOWN_reboot);
 310 }
 311
 312 #else
 313 extern void xenpci_resume(void);
 314
 315 /* HVM mode suspension. */
 316 static void
 317 xctrl_suspend()
 318 {
 319         int suspend_cancelled;
 320
 321         if (DEVICE_SUSPEND(root_bus)) {
 322                 printf("xen_suspend: device_suspend failed\n");
 323                 return;
 324         }
 325
 326         /*
 327          * Make sure we don't change cpus or switch to some other
 328          * thread. for the duration.
 329          */
 330         critical_enter();
 331
 332         /*
 333          * Prevent any races with evtchn_interrupt() handler.
 334          */
 335         irq_suspend();
 336         disable_intr();
 337
 338         suspend_cancelled = HYPERVISOR_suspend(0);
 339         if (!suspend_cancelled)
 340                 xenpci_resume();
 341
 342         /*
 343          * Re-enable interrupts and put the scheduler back to normal.
 344          */
 345         enable_intr();
 346         critical_exit();
 347
 348         /*
 349          * FreeBSD really needs to add DEVICE_SUSPEND_CANCEL or
 350          * similar.
 351          */
 352         if (!suspend_cancelled)
 353                 DEVICE_RESUME(root_bus);
 354 }
 355 #endif
 356
 357 static void
 358 xctrl_crash()
 359 {
 360         panic("Xen directed crash");
 361 }
 362
 363 static void
 364 xctrl_halt()
 365 {
 366         shutdown_nice(RB_HALT);
 367 }
 368
 369 /*------------------------------ Event Reception -----------------------------*/
 370 static void
 371 xctrl_on_watch_event(struct xs_watch *watch, const char **vec, unsigned int len)
 372 {
 373         struct xctrl_shutdown_reason *reason;
 374         struct xctrl_shutdown_reason *last_reason;
 375         char *result;
 376         int   error;
 377         int   result_len;
 378
 379         error = xs_read(XST_NIL, "control", "shutdown",
 380                         &result_len, (void **)&result);
 381         if (error != 0)
 382                 return;
 383
 384         reason = xctrl_shutdown_reasons;
 385         last_reason = reason + NUM_ELEMENTS(xctrl_shutdown_reasons);
 386         while (reason < last_reason) {
 387
 388                 if (!strcmp(result, reason->name)) {
 389                         reason->handler();
 390                         break;
 391                 }
 392                 reason++;
 393         }
 394
 395         free(result, M_XENSTORE);
 396 }
 397
 398 /*------------------ Private Device Attachment Functions  --------------------*/
 399 /**
 400  * \brief Identify instances of this device type in the system.
 401  *
 402  * \param driver  The driver performing this identify action.
 403  * \param parent  The NewBus parent device for any devices this method adds.
 404  */
 405 static void
 406 xctrl_identify(driver_t *driver __unused, device_t parent)
 407 {
 408         /*
 409          * A single device instance for our driver is always present
 410          * in a system operating under Xen.
 411          */
 412         BUS_ADD_CHILD(parent, 0, driver->name, 0);
 413 }
 414
 415 /**
 416  * \brief Probe for the existance of the Xen Control device
 417  *
 418  * \param dev  NewBus device_t for this Xen control instance.
 419  *
 420  * \return  Always returns 0 indicating success.
 421  */
 422 static int
 423 xctrl_probe(device_t dev)
 424 {
 425         device_set_desc(dev, "Xen Control Device");
 426
 427         return (0);
 428 }
 429
 430 /**
 431  * \brief Attach the Xen control device.
 432  *
 433  * \param dev  NewBus device_t for this Xen control instance.
 434  *
 435  * \return  On success, 0. Otherwise an errno value indicating the
 436  *          type of failure.
 437  */
 438 static int
 439 xctrl_attach(device_t dev)
 440 {
 441         struct xctrl_softc *xctrl;
 442
 443         xctrl = device_get_softc(dev);
 444
 445         /* Activate watch */
 446         xctrl->xctrl_watch.node = "control/shutdown";
 447         xctrl->xctrl_watch.callback = xctrl_on_watch_event;
 448         xs_register_watch(&xctrl->xctrl_watch);
 449
 450 #ifndef XENHVM
 451         EVENTHANDLER_REGISTER(shutdown_final, xen_pv_shutdown_final, NULL,
 452                               SHUTDOWN_PRI_LAST);
 453 #endif
 454
 455         return (0);
 456 }
 457
 458 /**
 459  * \brief Detach the Xen control device.
 460  *
 461  * \param dev  NewBus device_t for this Xen control device instance.
 462  *
 463  * \return  On success, 0. Otherwise an errno value indicating the
 464  *          type of failure.
 465  */
 466 static int
 467 xctrl_detach(device_t dev)
 468 {
 469         struct xctrl_softc *xctrl;
 470
 471         xctrl = device_get_softc(dev);
 472
 473         /* Release watch */
 474         xs_unregister_watch(&xctrl->xctrl_watch);
 475
 476         return (0);
 477 }
 478
 479 /*-------------------- Private Device Attachment Data  -----------------------*/
 480 static device_method_t xctrl_methods[] = {
 481         /* Device interface */
 482         DEVMETHOD(device_identify,      xctrl_identify),
 483         DEVMETHOD(device_probe,         xctrl_probe),
 484         DEVMETHOD(device_attach,        xctrl_attach),
 485         DEVMETHOD(device_detach,        xctrl_detach),
 486
 487         { 0, 0 }
 488 };
 489
 490 DEFINE_CLASS_0(xctrl, xctrl_driver, xctrl_methods, sizeof(struct xctrl_softc));
 491 devclass_t xctrl_devclass;
 492
 493 DRIVER_MODULE(xctrl, xenstore, xctrl_driver, xctrl_devclass, 0, 0);