arch/x86/xen/smp.c

   1 /*
   2  * Xen SMP support
   3  *
   4  * This file implements the Xen versions of smp_ops.  SMP under Xen is
   5  * very straightforward.  Bringing a CPU up is simply a matter of
   6  * loading its initial context and setting it running.
   7  *
   8  * IPIs are handled through the Xen event mechanism.
   9  *
  10  * Because virtual CPUs can be scheduled onto any real CPU, there's no
  11  * useful topology information for the kernel to make use of.  As a
  12  * result, all CPUs are treated as if they're single-core and
  13  * single-threaded.
  14  */
  15 #include <linux/sched.h>
  16 #include <linux/err.h>
  17 #include <linux/slab.h>
  18 #include <linux/smp.h>
  19 #include <linux/irq_work.h>
  20
  21 #include <asm/paravirt.h>
  22 #include <asm/desc.h>
  23 #include <asm/pgtable.h>
  24 #include <asm/cpu.h>
  25
  26 #include <xen/interface/xen.h>
  27 #include <xen/interface/vcpu.h>
  28
  29 #include <asm/xen/interface.h>
  30 #include <asm/xen/hypercall.h>
  31
  32 #include <xen/xen.h>
  33 #include <xen/page.h>
  34 #include <xen/events.h>
  35
  36 #include <xen/hvc-console.h>
  37 #include "xen-ops.h"
  38 #include "mmu.h"
  39
  40 cpumask_var_t xen_cpu_initialized_map;
  41
  42 static DEFINE_PER_CPU(int, xen_resched_irq);
  43 static DEFINE_PER_CPU(int, xen_callfunc_irq);
  44 static DEFINE_PER_CPU(int, xen_callfuncsingle_irq);
  45 static DEFINE_PER_CPU(int, xen_irq_work);
  46 static DEFINE_PER_CPU(int, xen_debug_irq) = -1;
  47
  48 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
  49 static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
  50 static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id);
  51
  52 /*
  53  * Reschedule call back.
  54  */
  55 static irqreturn_t xen_reschedule_interrupt(int irq, void *dev_id)
  56 {
  57         inc_irq_stat(irq_resched_count);
  58         scheduler_ipi();
  59
  60         return IRQ_HANDLED;
  61 }
  62
  63 static void __cpuinit cpu_bringup(void)
  64 {
  65         int cpu;
  66
  67         cpu_init();
  68         touch_softlockup_watchdog();
  69         preempt_disable();
  70
  71         xen_enable_sysenter();
  72         xen_enable_syscall();
  73
  74         cpu = smp_processor_id();
  75         smp_store_cpu_info(cpu);
  76         cpu_data(cpu).x86_max_cores = 1;
  77         set_cpu_sibling_map(cpu);
  78
  79         xen_setup_cpu_clockevents();
  80
  81         notify_cpu_starting(cpu);
  82
  83         ipi_call_lock();
  84         set_cpu_online(cpu, true);
  85         ipi_call_unlock();
  86
  87         this_cpu_write(cpu_state, CPU_ONLINE);
  88
  89         wmb();
  90
  91         /* We can take interrupts now: we're officially "up". */
  92         local_irq_enable();
  93
  94         wmb();                  /* make sure everything is out */
  95 }
  96
  97 static void __cpuinit cpu_bringup_and_idle(void)
  98 {
  99         cpu_bringup();
 100         cpu_idle();
 101 }
 102
 103 static int xen_smp_intr_init(unsigned int cpu)
 104 {
 105         int rc;
 106         const char *resched_name, *callfunc_name, *debug_name;
 107
 108         resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);
 109         rc = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR,
 110                                     cpu,
 111                                     xen_reschedule_interrupt,
 112                                     IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,
 113                                     resched_name,
 114                                     NULL);
 115         if (rc < 0)
 116                 goto fail;
 117         per_cpu(xen_resched_irq, cpu) = rc;
 118
 119         callfunc_name = kasprintf(GFP_KERNEL, "callfunc%d", cpu);
 120         rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_VECTOR,
 121                                     cpu,
 122                                     xen_call_function_interrupt,
 123                                     IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,
 124                                     callfunc_name,
 125                                     NULL);
 126         if (rc < 0)
 127                 goto fail;
 128         per_cpu(xen_callfunc_irq, cpu) = rc;
 129
 130         debug_name = kasprintf(GFP_KERNEL, "debug%d", cpu);
 131         rc = bind_virq_to_irqhandler(VIRQ_DEBUG, cpu, xen_debug_interrupt,
 132                                      IRQF_DISABLED | IRQF_PERCPU | IRQF_NOBALANCING,
 133                                      debug_name, NULL);
 134         if (rc < 0)
 135                 goto fail;
 136         per_cpu(xen_debug_irq, cpu) = rc;
 137
 138         callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
 139         rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,
 140                                     cpu,
 141                                     xen_call_function_single_interrupt,
 142                                     IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,
 143                                     callfunc_name,
 144                                     NULL);
 145         if (rc < 0)
 146                 goto fail;
 147         per_cpu(xen_callfuncsingle_irq, cpu) = rc;
 148
 149         callfunc_name = kasprintf(GFP_KERNEL, "irqwork%d", cpu);
 150         rc = bind_ipi_to_irqhandler(XEN_IRQ_WORK_VECTOR,
 151                                     cpu,
 152                                     xen_irq_work_interrupt,
 153                                     IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,
 154                                     callfunc_name,
 155                                     NULL);
 156         if (rc < 0)
 157                 goto fail;
 158         per_cpu(xen_irq_work, cpu) = rc;
 159
 160         return 0;
 161
 162  fail:
 163         if (per_cpu(xen_resched_irq, cpu) >= 0)
 164                 unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);
 165         if (per_cpu(xen_callfunc_irq, cpu) >= 0)
 166                 unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);
 167         if (per_cpu(xen_debug_irq, cpu) >= 0)
 168                 unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);
 169         if (per_cpu(xen_callfuncsingle_irq, cpu) >= 0)
 170                 unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu),
 171                                        NULL);
 172         if (per_cpu(xen_irq_work, cpu) >= 0)
 173                 unbind_from_irqhandler(per_cpu(xen_irq_work, cpu), NULL);
 174
 175         return rc;
 176 }
 177
 178 static void __init xen_fill_possible_map(void)
 179 {
 180         int i, rc;
 181
 182         if (xen_initial_domain())
 183                 return;
 184
 185         for (i = 0; i < nr_cpu_ids; i++) {
 186                 rc = HYPERVISOR_vcpu_op(VCPUOP_is_up, i, NULL);
 187                 if (rc >= 0) {
 188                         num_processors++;
 189                         set_cpu_possible(i, true);
 190                 }
 191         }
 192 }
 193
 194 static void __init xen_filter_cpu_maps(void)
 195 {
 196         int i, rc;
 197
 198         if (!xen_initial_domain())
 199                 return;
 200
 201         num_processors = 0;
 202         disabled_cpus = 0;
 203         for (i = 0; i < nr_cpu_ids; i++) {
 204                 rc = HYPERVISOR_vcpu_op(VCPUOP_is_up, i, NULL);
 205                 if (rc >= 0) {
 206                         num_processors++;
 207                         set_cpu_possible(i, true);
 208                 } else {
 209                         set_cpu_possible(i, false);
 210                         set_cpu_present(i, false);
 211                 }
 212         }
 213 }
 214
 215 static void __init xen_smp_prepare_boot_cpu(void)
 216 {
 217         BUG_ON(smp_processor_id() != 0);
 218         native_smp_prepare_boot_cpu();
 219
 220         /* We've switched to the "real" per-cpu gdt, so make sure the
 221            old memory can be recycled */
 222         make_lowmem_page_readwrite(xen_initial_gdt);
 223
 224         xen_filter_cpu_maps();
 225         xen_setup_vcpu_info_placement();
 226 }
 227
 228 static void __init xen_smp_prepare_cpus(unsigned int max_cpus)
 229 {
 230         unsigned cpu;
 231         unsigned int i;
 232
 233         if (skip_ioapic_setup) {
 234                 char *m = (max_cpus == 0) ?
 235                         "The nosmp parameter is incompatible with Xen; " \
 236                         "use Xen dom0_max_vcpus=1 parameter" :
 237                         "The noapic parameter is incompatible with Xen";
 238
 239                 xen_raw_printk(m);
 240                 panic(m);
 241         }
 242         xen_init_lock_cpu(0);
 243
 244         smp_store_cpu_info(0);
 245         cpu_data(0).x86_max_cores = 1;
 246
 247         for_each_possible_cpu(i) {
 248                 zalloc_cpumask_var(&per_cpu(cpu_sibling_map, i), GFP_KERNEL);
 249                 zalloc_cpumask_var(&per_cpu(cpu_core_map, i), GFP_KERNEL);
 250                 zalloc_cpumask_var(&per_cpu(cpu_llc_shared_map, i), GFP_KERNEL);
 251         }
 252         set_cpu_sibling_map(0);
 253
 254         if (xen_smp_intr_init(0))
 255                 BUG();
 256
 257         if (!alloc_cpumask_var(&xen_cpu_initialized_map, GFP_KERNEL))
 258                 panic("could not allocate xen_cpu_initialized_map\n");
 259
 260         cpumask_copy(xen_cpu_initialized_map, cpumask_of(0));
 261
 262         /* Restrict the possible_map according to max_cpus. */
 263         while ((num_possible_cpus() > 1) && (num_possible_cpus() > max_cpus)) {
 264                 for (cpu = nr_cpu_ids - 1; !cpu_possible(cpu); cpu--)
 265                         continue;
 266                 set_cpu_possible(cpu, false);
 267         }
 268
 269         for_each_possible_cpu (cpu) {
 270                 struct task_struct *idle;
 271
 272                 if (cpu == 0)
 273                         continue;
 274
 275                 idle = fork_idle(cpu);
 276                 if (IS_ERR(idle))
 277                         panic("failed fork for CPU %d", cpu);
 278
 279                 set_cpu_present(cpu, true);
 280         }
 281 }
 282
 283 static int __cpuinit
 284 cpu_initialize_context(unsigned int cpu, struct task_struct *idle)
 285 {
 286         struct vcpu_guest_context *ctxt;
 287         struct desc_struct *gdt;
 288         unsigned long gdt_mfn;
 289
 290         if (cpumask_test_and_set_cpu(cpu, xen_cpu_initialized_map))
 291                 return 0;
 292
 293         ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
 294         if (ctxt == NULL)
 295                 return -ENOMEM;
 296
 297         gdt = get_cpu_gdt_table(cpu);
 298
 299         ctxt->flags = VGCF_IN_KERNEL;
 300         ctxt->user_regs.ds = __USER_DS;
 301         ctxt->user_regs.es = __USER_DS;
 302         ctxt->user_regs.ss = __KERNEL_DS;
 303 #ifdef CONFIG_X86_32
 304         ctxt->user_regs.fs = __KERNEL_PERCPU;
 305         ctxt->user_regs.gs = __KERNEL_STACK_CANARY;
 306 #else
 307         ctxt->gs_base_kernel = per_cpu_offset(cpu);
 308 #endif
 309         ctxt->user_regs.eip = (unsigned long)cpu_bringup_and_idle;
 310         ctxt->user_regs.eflags = 0x1000; /* IOPL_RING1 */
 311
 312         memset(&ctxt->fpu_ctxt, 0, sizeof(ctxt->fpu_ctxt));
 313
 314         xen_copy_trap_info(ctxt->trap_ctxt);
 315
 316         ctxt->ldt_ents = 0;
 317
 318         BUG_ON((unsigned long)gdt & ~PAGE_MASK);
 319
 320         gdt_mfn = arbitrary_virt_to_mfn(gdt);
 321         make_lowmem_page_readonly(gdt);
 322         make_lowmem_page_readonly(mfn_to_virt(gdt_mfn));
 323
 324         ctxt->gdt_frames[0] = gdt_mfn;
 325         ctxt->gdt_ents      = GDT_ENTRIES;
 326
 327         ctxt->user_regs.cs = __KERNEL_CS;
 328         ctxt->user_regs.esp = idle->thread.sp0 - sizeof(struct pt_regs);
 329
 330         ctxt->kernel_ss = __KERNEL_DS;
 331         ctxt->kernel_sp = idle->thread.sp0;
 332
 333 #ifdef CONFIG_X86_32
 334         ctxt->event_callback_cs     = __KERNEL_CS;
 335         ctxt->failsafe_callback_cs  = __KERNEL_CS;
 336 #endif
 337         ctxt->event_callback_eip    = (unsigned long)xen_hypervisor_callback;
 338         ctxt->failsafe_callback_eip = (unsigned long)xen_failsafe_callback;
 339
 340         per_cpu(xen_cr3, cpu) = __pa(swapper_pg_dir);
 341         ctxt->ctrlreg[3] = xen_pfn_to_cr3(virt_to_mfn(swapper_pg_dir));
 342
 343         if (HYPERVISOR_vcpu_op(VCPUOP_initialise, cpu, ctxt))
 344                 BUG();
 345
 346         kfree(ctxt);
 347         return 0;
 348 }
 349
 350 static int __cpuinit xen_cpu_up(unsigned int cpu)
 351 {
 352         struct task_struct *idle = idle_task(cpu);
 353         int rc;
 354
 355         per_cpu(current_task, cpu) = idle;
 356 #ifdef CONFIG_X86_32
 357         irq_ctx_init(cpu);
 358 #else
 359         clear_tsk_thread_flag(idle, TIF_FORK);
 360         per_cpu(kernel_stack, cpu) =
 361                 (unsigned long)task_stack_page(idle) -
 362                 KERNEL_STACK_OFFSET + THREAD_SIZE;
 363 #endif
 364         xen_setup_runstate_info(cpu);
 365         xen_setup_timer(cpu);
 366         xen_init_lock_cpu(cpu);
 367
 368         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
 369
 370         /* make sure interrupts start blocked */
 371         per_cpu(xen_vcpu, cpu)->evtchn_upcall_mask = 1;
 372
 373         rc = cpu_initialize_context(cpu, idle);
 374         if (rc)
 375                 return rc;
 376
 377         if (num_online_cpus() == 1)
 378                 alternatives_smp_switch(1);
 379
 380         rc = xen_smp_intr_init(cpu);
 381         if (rc)
 382                 return rc;
 383
 384         rc = HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL);
 385         BUG_ON(rc);
 386
 387         while(per_cpu(cpu_state, cpu) != CPU_ONLINE) {
 388                 HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
 389                 barrier();
 390         }
 391
 392         return 0;
 393 }
 394
 395 static void xen_smp_cpus_done(unsigned int max_cpus)
 396 {
 397 }
 398
 399 #ifdef CONFIG_HOTPLUG_CPU
 400 static int xen_cpu_disable(void)
 401 {
 402         unsigned int cpu = smp_processor_id();
 403         if (cpu == 0)
 404                 return -EBUSY;
 405
 406         cpu_disable_common();
 407
 408         load_cr3(swapper_pg_dir);
 409         return 0;
 410 }
 411
 412 static void xen_cpu_die(unsigned int cpu)
 413 {
 414         while (HYPERVISOR_vcpu_op(VCPUOP_is_up, cpu, NULL)) {
 415                 current->state = TASK_UNINTERRUPTIBLE;
 416                 schedule_timeout(HZ/10);
 417         }
 418         unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);
 419         unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);
 420         unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);
 421         unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu), NULL);
 422         xen_uninit_lock_cpu(cpu);
 423         xen_teardown_timer(cpu);
 424
 425         if (num_online_cpus() == 1)
 426                 alternatives_smp_switch(0);
 427 }
 428
 429 static void __cpuinit xen_play_dead(void) /* used only with HOTPLUG_CPU */
 430 {
 431         play_dead_common();
 432         HYPERVISOR_vcpu_op(VCPUOP_down, smp_processor_id(), NULL);
 433         cpu_bringup();
 434         /*
 435          * Balance out the preempt calls - as we are running in cpu_idle
 436          * loop which has been called at bootup from cpu_bringup_and_idle.
 437          * The cpucpu_bringup_and_idle called cpu_bringup which made a
 438          * preempt_disable() So this preempt_enable will balance it out.
 439          */
 440         preempt_enable();
 441 }
 442
 443 #else /* !CONFIG_HOTPLUG_CPU */
 444 static int xen_cpu_disable(void)
 445 {
 446         return -ENOSYS;
 447 }
 448
 449 static void xen_cpu_die(unsigned int cpu)
 450 {
 451         BUG();
 452 }
 453
 454 static void xen_play_dead(void)
 455 {
 456         BUG();
 457 }
 458
 459 #endif
 460 static void stop_self(void *v)
 461 {
 462         int cpu = smp_processor_id();
 463
 464         /* make sure we're not pinning something down */
 465         load_cr3(swapper_pg_dir);
 466         /* should set up a minimal gdt */
 467
 468         set_cpu_online(cpu, false);
 469
 470         HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL);
 471         BUG();
 472 }
 473
 474 static void xen_stop_other_cpus(int wait)
 475 {
 476         smp_call_function(stop_self, NULL, wait);
 477 }
 478
 479 static void xen_smp_send_reschedule(int cpu)
 480 {
 481         xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
 482 }
 483
 484 static void __xen_send_IPI_mask(const struct cpumask *mask,
 485                               int vector)
 486 {
 487         unsigned cpu;
 488
 489         for_each_cpu_and(cpu, mask, cpu_online_mask)
 490                 xen_send_IPI_one(cpu, vector);
 491 }
 492
 493 static void xen_smp_send_call_function_ipi(const struct cpumask *mask)
 494 {
 495         int cpu;
 496
 497         __xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
 498
 499         /* Make sure other vcpus get a chance to run if they need to. */
 500         for_each_cpu(cpu, mask) {
 501                 if (xen_vcpu_stolen(cpu)) {
 502                         HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
 503                         break;
 504                 }
 505         }
 506 }
 507
 508 static void xen_smp_send_call_function_single_ipi(int cpu)
 509 {
 510         __xen_send_IPI_mask(cpumask_of(cpu),
 511                           XEN_CALL_FUNCTION_SINGLE_VECTOR);
 512 }
 513
 514 static inline int xen_map_vector(int vector)
 515 {
 516         int xen_vector;
 517
 518         switch (vector) {
 519         case RESCHEDULE_VECTOR:
 520                 xen_vector = XEN_RESCHEDULE_VECTOR;
 521                 break;
 522         case CALL_FUNCTION_VECTOR:
 523                 xen_vector = XEN_CALL_FUNCTION_VECTOR;
 524                 break;
 525         case CALL_FUNCTION_SINGLE_VECTOR:
 526                 xen_vector = XEN_CALL_FUNCTION_SINGLE_VECTOR;
 527                 break;
 528         case IRQ_WORK_VECTOR:
 529                 xen_vector = XEN_IRQ_WORK_VECTOR;
 530                 break;
 531         default:
 532                 xen_vector = -1;
 533                 printk(KERN_ERR "xen: vector 0x%x is not implemented\n",
 534                         vector);
 535         }
 536
 537         return xen_vector;
 538 }
 539
 540 void xen_send_IPI_mask(const struct cpumask *mask,
 541                               int vector)
 542 {
 543         int xen_vector = xen_map_vector(vector);
 544
 545         if (xen_vector >= 0)
 546                 __xen_send_IPI_mask(mask, xen_vector);
 547 }
 548
 549 void xen_send_IPI_all(int vector)
 550 {
 551         int xen_vector = xen_map_vector(vector);
 552
 553         if (xen_vector >= 0)
 554                 __xen_send_IPI_mask(cpu_online_mask, xen_vector);
 555 }
 556
 557 void xen_send_IPI_self(int vector)
 558 {
 559         int xen_vector = xen_map_vector(vector);
 560
 561         if (xen_vector >= 0)
 562                 xen_send_IPI_one(smp_processor_id(), xen_vector);
 563 }
 564
 565 void xen_send_IPI_mask_allbutself(const struct cpumask *mask,
 566                                 int vector)
 567 {
 568         unsigned cpu;
 569         unsigned int this_cpu = smp_processor_id();
 570
 571         if (!(num_online_cpus() > 1))
 572                 return;
 573
 574         for_each_cpu_and(cpu, mask, cpu_online_mask) {
 575                 if (this_cpu == cpu)
 576                         continue;
 577
 578                 xen_smp_send_call_function_single_ipi(cpu);
 579         }
 580 }
 581
 582 void xen_send_IPI_allbutself(int vector)
 583 {
 584         int xen_vector = xen_map_vector(vector);
 585
 586         if (xen_vector >= 0)
 587                 xen_send_IPI_mask_allbutself(cpu_online_mask, xen_vector);
 588 }
 589
 590 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
 591 {
 592         irq_enter();
 593         generic_smp_call_function_interrupt();
 594         inc_irq_stat(irq_call_count);
 595         irq_exit();
 596
 597         return IRQ_HANDLED;
 598 }
 599
 600 static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id)
 601 {
 602         irq_enter();
 603         generic_smp_call_function_single_interrupt();
 604         inc_irq_stat(irq_call_count);
 605         irq_exit();
 606
 607         return IRQ_HANDLED;
 608 }
 609
 610 static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id)
 611 {
 612         irq_enter();
 613         irq_work_run();
 614         inc_irq_stat(apic_irq_work_irqs);
 615         irq_exit();
 616
 617         return IRQ_HANDLED;
 618 }
 619
 620 static const struct smp_ops xen_smp_ops __initconst = {
 621         .smp_prepare_boot_cpu = xen_smp_prepare_boot_cpu,
 622         .smp_prepare_cpus = xen_smp_prepare_cpus,
 623         .smp_cpus_done = xen_smp_cpus_done,
 624
 625         .cpu_up = xen_cpu_up,
 626         .cpu_die = xen_cpu_die,
 627         .cpu_disable = xen_cpu_disable,
 628         .play_dead = xen_play_dead,
 629
 630         .stop_other_cpus = xen_stop_other_cpus,
 631         .smp_send_reschedule = xen_smp_send_reschedule,
 632
 633         .send_call_func_ipi = xen_smp_send_call_function_ipi,
 634         .send_call_func_single_ipi = xen_smp_send_call_function_single_ipi,
 635 };
 636
 637 void __init xen_smp_init(void)
 638 {
 639         smp_ops = xen_smp_ops;
 640         xen_fill_possible_map();
 641         xen_init_spinlocks();
 642 }
 643
 644 static void __init xen_hvm_smp_prepare_cpus(unsigned int max_cpus)
 645 {
 646         native_smp_prepare_cpus(max_cpus);
 647         WARN_ON(xen_smp_intr_init(0));
 648
 649         xen_init_lock_cpu(0);
 650 }
 651
 652 static int __cpuinit xen_hvm_cpu_up(unsigned int cpu)
 653 {
 654         int rc;
 655         rc = native_cpu_up(cpu);
 656         WARN_ON (xen_smp_intr_init(cpu));
 657         return rc;
 658 }
 659
 660 static void xen_hvm_cpu_die(unsigned int cpu)
 661 {
 662         unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);
 663         unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);
 664         unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);
 665         unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu), NULL);
 666         unbind_from_irqhandler(per_cpu(xen_irq_work, cpu), NULL);
 667         native_cpu_die(cpu);
 668 }
 669
 670 void __init xen_hvm_smp_init(void)
 671 {
 672         if (!xen_have_vector_callback)
 673                 return;
 674         smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus;
 675         smp_ops.smp_send_reschedule = xen_smp_send_reschedule;
 676         smp_ops.cpu_up = xen_hvm_cpu_up;
 677         smp_ops.cpu_die = xen_hvm_cpu_die;
 678         smp_ops.send_call_func_ipi = xen_smp_send_call_function_ipi;
 679         smp_ops.send_call_func_single_ipi = xen_smp_send_call_function_single_ipi;
 680 }