drivers/lguest/hypercalls.c

   1 /*P:500 Just as userspace programs request kernel operations through a system
   2  * call, the Guest requests Host operations through a "hypercall".  You might
   3  * notice this nomenclature doesn't really follow any logic, but the name has
   4  * been around for long enough that we're stuck with it.  As you'd expect, this
   5  * code is basically a one big switch statement. :*/
   6
   7 /*  Copyright (C) 2006 Rusty Russell IBM Corporation
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  22 */
  23 #include <linux/uaccess.h>
  24 #include <linux/syscalls.h>
  25 #include <linux/mm.h>
  26 #include <asm/page.h>
  27 #include <asm/pgtable.h>
  28 #include <irq_vectors.h>
  29 #include "lg.h"
  30
  31 /*H:120 This is the core hypercall routine: where the Guest gets what it
  32  * wants.  Or gets killed.  Or, in the case of LHCALL_CRASH, both.
  33  *
  34  * Remember from the Guest: %eax == which call to make, and the arguments are
  35  * packed into %edx, %ebx and %ecx if needed. */
  36 static void do_hcall(struct lguest *lg, struct lguest_regs *regs)
  37 {
  38         switch (regs->eax) {
  39         case LHCALL_FLUSH_ASYNC:
  40                 /* This call does nothing, except by breaking out of the Guest
  41                  * it makes us process all the asynchronous hypercalls. */
  42                 break;
  43         case LHCALL_LGUEST_INIT:
  44                 /* You can't get here unless you're already initialized.  Don't
  45                  * do that. */
  46                 kill_guest(lg, "already have lguest_data");
  47                 break;
  48         case LHCALL_CRASH: {
  49                 /* Crash is such a trivial hypercall that we do it in four
  50                  * lines right here. */
  51                 char msg[128];
  52                 /* If the lgread fails, it will call kill_guest() itself; the
  53                  * kill_guest() with the message will be ignored. */
  54                 lgread(lg, msg, regs->edx, sizeof(msg));
  55                 msg[sizeof(msg)-1] = '\0';
  56                 kill_guest(lg, "CRASH: %s", msg);
  57                 break;
  58         }
  59         case LHCALL_FLUSH_TLB:
  60                 /* FLUSH_TLB comes in two flavors, depending on the
  61                  * argument: */
  62                 if (regs->edx)
  63                         guest_pagetable_clear_all(lg);
  64                 else
  65                         guest_pagetable_flush_user(lg);
  66                 break;
  67         case LHCALL_BIND_DMA:
  68                 /* BIND_DMA really wants four arguments, but it's the only call
  69                  * which does.  So the Guest packs the number of buffers and
  70                  * the interrupt number into the final argument, and we decode
  71                  * it here.  This can legitimately fail, since we currently
  72                  * place a limit on the number of DMA pools a Guest can have.
  73                  * So we return true or false from this call. */
  74                 regs->eax = bind_dma(lg, regs->edx, regs->ebx,
  75                                      regs->ecx >> 8, regs->ecx & 0xFF);
  76                 break;
  77
  78         /* All these calls simply pass the arguments through to the right
  79          * routines. */
  80         case LHCALL_SEND_DMA:
  81                 send_dma(lg, regs->edx, regs->ebx);
  82                 break;
  83         case LHCALL_LOAD_GDT:
  84                 load_guest_gdt(lg, regs->edx, regs->ebx);
  85                 break;
  86         case LHCALL_LOAD_IDT_ENTRY:
  87                 load_guest_idt_entry(lg, regs->edx, regs->ebx, regs->ecx);
  88                 break;
  89         case LHCALL_NEW_PGTABLE:
  90                 guest_new_pagetable(lg, regs->edx);
  91                 break;
  92         case LHCALL_SET_STACK:
  93                 guest_set_stack(lg, regs->edx, regs->ebx, regs->ecx);
  94                 break;
  95         case LHCALL_SET_PTE:
  96                 guest_set_pte(lg, regs->edx, regs->ebx, mkgpte(regs->ecx));
  97                 break;
  98         case LHCALL_SET_PMD:
  99                 guest_set_pmd(lg, regs->edx, regs->ebx);
 100                 break;
 101         case LHCALL_LOAD_TLS:
 102                 guest_load_tls(lg, regs->edx);
 103                 break;
 104         case LHCALL_SET_CLOCKEVENT:
 105                 guest_set_clockevent(lg, regs->edx);
 106                 break;
 107
 108         case LHCALL_TS:
 109                 /* This sets the TS flag, as we saw used in run_guest(). */
 110                 lg->ts = regs->edx;
 111                 break;
 112         case LHCALL_HALT:
 113                 /* Similarly, this sets the halted flag for run_guest(). */
 114                 lg->halted = 1;
 115                 break;
 116         default:
 117                 kill_guest(lg, "Bad hypercall %li\n", regs->eax);
 118         }
 119 }
 120
 121 /* Asynchronous hypercalls are easy: we just look in the array in the Guest's
 122  * "struct lguest_data" and see if there are any new ones marked "ready".
 123  *
 124  * We are careful to do these in order: obviously we respect the order the
 125  * Guest put them in the ring, but we also promise the Guest that they will
 126  * happen before any normal hypercall (which is why we check this before
 127  * checking for a normal hcall). */
 128 static void do_async_hcalls(struct lguest *lg)
 129 {
 130         unsigned int i;
 131         u8 st[LHCALL_RING_SIZE];
 132
 133         /* For simplicity, we copy the entire call status array in at once. */
 134         if (copy_from_user(&st, &lg->lguest_data->hcall_status, sizeof(st)))
 135                 return;
 136
 137
 138         /* We process "struct lguest_data"s hcalls[] ring once. */
 139         for (i = 0; i < ARRAY_SIZE(st); i++) {
 140                 struct lguest_regs regs;
 141                 /* We remember where we were up to from last time.  This makes
 142                  * sure that the hypercalls are done in the order the Guest
 143                  * places them in the ring. */
 144                 unsigned int n = lg->next_hcall;
 145
 146                 /* 0xFF means there's no call here (yet). */
 147                 if (st[n] == 0xFF)
 148                         break;
 149
 150                 /* OK, we have hypercall.  Increment the "next_hcall" cursor,
 151                  * and wrap back to 0 if we reach the end. */
 152                 if (++lg->next_hcall == LHCALL_RING_SIZE)
 153                         lg->next_hcall = 0;
 154
 155                 /* We copy the hypercall arguments into a fake register
 156                  * structure.  This makes life simple for do_hcall(). */
 157                 if (get_user(regs.eax, &lg->lguest_data->hcalls[n].eax)
 158                     || get_user(regs.edx, &lg->lguest_data->hcalls[n].edx)
 159                     || get_user(regs.ecx, &lg->lguest_data->hcalls[n].ecx)
 160                     || get_user(regs.ebx, &lg->lguest_data->hcalls[n].ebx)) {
 161                         kill_guest(lg, "Fetching async hypercalls");
 162                         break;
 163                 }
 164
 165                 /* Do the hypercall, same as a normal one. */
 166                 do_hcall(lg, &regs);
 167
 168                 /* Mark the hypercall done. */
 169                 if (put_user(0xFF, &lg->lguest_data->hcall_status[n])) {
 170                         kill_guest(lg, "Writing result for async hypercall");
 171                         break;
 172                 }
 173
 174                 /* Stop doing hypercalls if we've just done a DMA to the
 175                  * Launcher: it needs to service this first. */
 176                 if (lg->dma_is_pending)
 177                         break;
 178         }
 179 }
 180
 181 /* Last of all, we look at what happens first of all.  The very first time the
 182  * Guest makes a hypercall, we end up here to set things up: */
 183 static void initialize(struct lguest *lg)
 184 {
 185         u32 tsc_speed;
 186
 187         /* You can't do anything until you're initialized.  The Guest knows the
 188          * rules, so we're unforgiving here. */
 189         if (lg->regs->eax != LHCALL_LGUEST_INIT) {
 190                 kill_guest(lg, "hypercall %li before LGUEST_INIT",
 191                            lg->regs->eax);
 192                 return;
 193         }
 194
 195         /* We insist that the Time Stamp Counter exist and doesn't change with
 196          * cpu frequency.  Some devious chip manufacturers decided that TSC
 197          * changes could be handled in software.  I decided that time going
 198          * backwards might be good for benchmarks, but it's bad for users.
 199          *
 200          * We also insist that the TSC be stable: the kernel detects unreliable
 201          * TSCs for its own purposes, and we use that here. */
 202         if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) && !check_tsc_unstable())
 203                 tsc_speed = tsc_khz;
 204         else
 205                 tsc_speed = 0;
 206
 207         /* The pointer to the Guest's "struct lguest_data" is the only
 208          * argument. */
 209         lg->lguest_data = (struct lguest_data __user *)lg->regs->edx;
 210         /* If we check the address they gave is OK now, we can simply
 211          * copy_to_user/from_user from now on rather than using lgread/lgwrite.
 212          * I put this in to show that I'm not immune to writing stupid
 213          * optimizations. */
 214         if (!lguest_address_ok(lg, lg->regs->edx, sizeof(*lg->lguest_data))) {
 215                 kill_guest(lg, "bad guest page %p", lg->lguest_data);
 216                 return;
 217         }
 218         /* The Guest tells us where we're not to deliver interrupts by putting
 219          * the range of addresses into "struct lguest_data". */
 220         if (get_user(lg->noirq_start, &lg->lguest_data->noirq_start)
 221             || get_user(lg->noirq_end, &lg->lguest_data->noirq_end)
 222             /* We tell the Guest that it can't use the top 4MB of virtual
 223              * addresses used by the Switcher. */
 224             || put_user(4U*1024*1024, &lg->lguest_data->reserve_mem)
 225             || put_user(tsc_speed, &lg->lguest_data->tsc_khz)
 226             /* We also give the Guest a unique id, as used in lguest_net.c. */
 227             || put_user(lg->guestid, &lg->lguest_data->guestid))
 228                 kill_guest(lg, "bad guest page %p", lg->lguest_data);
 229
 230         /* We write the current time into the Guest's data page once now. */
 231         write_timestamp(lg);
 232
 233         /* This is the one case where the above accesses might have been the
 234          * first write to a Guest page.  This may have caused a copy-on-write
 235          * fault, but the Guest might be referring to the old (read-only)
 236          * page. */
 237         guest_pagetable_clear_all(lg);
 238 }
 239 /* Now we've examined the hypercall code; our Guest can make requests.  There
 240  * is one other way we can do things for the Guest, as we see in
 241  * emulate_insn(). */
 242
 243 /*H:110 Tricky point: we mark the hypercall as "done" once we've done it.
 244  * Normally we don't need to do this: the Guest will run again and update the
 245  * trap number before we come back around the run_guest() loop to
 246  * do_hypercalls().
 247  *
 248  * However, if we are signalled or the Guest sends DMA to the Launcher, that
 249  * loop will exit without running the Guest.  When it comes back it would try
 250  * to re-run the hypercall. */
 251 static void clear_hcall(struct lguest *lg)
 252 {
 253         lg->regs->trapnum = 255;
 254 }
 255
 256 /*H:100
 257  * Hypercalls
 258  *
 259  * Remember from the Guest, hypercalls come in two flavors: normal and
 260  * asynchronous.  This file handles both of types.
 261  */
 262 void do_hypercalls(struct lguest *lg)
 263 {
 264         /* Not initialized yet? */
 265         if (unlikely(!lg->lguest_data)) {
 266                 /* Did the Guest make a hypercall?  We might have come back for
 267                  * some other reason (an interrupt, a different trap). */
 268                 if (lg->regs->trapnum == LGUEST_TRAP_ENTRY) {
 269                         /* Set up the "struct lguest_data" */
 270                         initialize(lg);
 271                         /* The hypercall is done. */
 272                         clear_hcall(lg);
 273                 }
 274                 return;
 275         }
 276
 277         /* The Guest has initialized.
 278          *
 279          * Look in the hypercall ring for the async hypercalls: */
 280         do_async_hcalls(lg);
 281
 282         /* If we stopped reading the hypercall ring because the Guest did a
 283          * SEND_DMA to the Launcher, we want to return now.  Otherwise if the
 284          * Guest asked us to do a hypercall, we do it. */
 285         if (!lg->dma_is_pending && lg->regs->trapnum == LGUEST_TRAP_ENTRY) {
 286                 do_hcall(lg, lg->regs);
 287                 /* The hypercall is done. */
 288                 clear_hcall(lg);
 289         }
 290 }
 291
 292 /* This routine supplies the Guest with time: it's used for wallclock time at
 293  * initial boot and as a rough time source if the TSC isn't available. */
 294 void write_timestamp(struct lguest *lg)
 295 {
 296         struct timespec now;
 297         ktime_get_real_ts(&now);
 298         if (copy_to_user(&lg->lguest_data->time, &now, sizeof(struct timespec)))
 299                 kill_guest(lg, "Writing timestamp");
 300 }