Documentation/virt/kvm/vcpu-requests.rst

   1 =================
   2 KVM VCPU Requests
   3 =================
   4
   5 Overview
   6 ========
   7
   8 KVM supports an internal API enabling threads to request a VCPU thread to
   9 perform some activity.  For example, a thread may request a VCPU to flush
  10 its TLB with a VCPU request.  The API consists of the following functions::
  11
  12   /* Check if any requests are pending for VCPU @vcpu. */
  13   bool kvm_request_pending(struct kvm_vcpu *vcpu);
  14
  15   /* Check if VCPU @vcpu has request @req pending. */
  16   bool kvm_test_request(int req, struct kvm_vcpu *vcpu);
  17
  18   /* Clear request @req for VCPU @vcpu. */
  19   void kvm_clear_request(int req, struct kvm_vcpu *vcpu);
  20
  21   /*
  22    * Check if VCPU @vcpu has request @req pending. When the request is
  23    * pending it will be cleared and a memory barrier, which pairs with
  24    * another in kvm_make_request(), will be issued.
  25    */
  26   bool kvm_check_request(int req, struct kvm_vcpu *vcpu);
  27
  28   /*
  29    * Make request @req of VCPU @vcpu. Issues a memory barrier, which pairs
  30    * with another in kvm_check_request(), prior to setting the request.
  31    */
  32   void kvm_make_request(int req, struct kvm_vcpu *vcpu);
  33
  34   /* Make request @req of all VCPUs of the VM with struct kvm @kvm. */
  35   bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req);
  36
  37 Typically a requester wants the VCPU to perform the activity as soon
  38 as possible after making the request.  This means most requests
  39 (kvm_make_request() calls) are followed by a call to kvm_vcpu_kick(),
  40 and kvm_make_all_cpus_request() has the kicking of all VCPUs built
  41 into it.
  42
  43 VCPU Kicks
  44 ----------
  45
  46 The goal of a VCPU kick is to bring a VCPU thread out of guest mode in
  47 order to perform some KVM maintenance.  To do so, an IPI is sent, forcing
  48 a guest mode exit.  However, a VCPU thread may not be in guest mode at the
  49 time of the kick.  Therefore, depending on the mode and state of the VCPU
  50 thread, there are two other actions a kick may take.  All three actions
  51 are listed below:
  52
  53 1) Send an IPI.  This forces a guest mode exit.
  54 2) Waking a sleeping VCPU.  Sleeping VCPUs are VCPU threads outside guest
  55    mode that wait on waitqueues.  Waking them removes the threads from
  56    the waitqueues, allowing the threads to run again.  This behavior
  57    may be suppressed, see KVM_REQUEST_NO_WAKEUP below.
  58 3) Nothing.  When the VCPU is not in guest mode and the VCPU thread is not
  59    sleeping, then there is nothing to do.
  60
  61 VCPU Mode
  62 ---------
  63
  64 VCPUs have a mode state, ``vcpu->mode``, that is used to track whether the
  65 guest is running in guest mode or not, as well as some specific
  66 outside guest mode states.  The architecture may use ``vcpu->mode`` to
  67 ensure VCPU requests are seen by VCPUs (see "Ensuring Requests Are Seen"),
  68 as well as to avoid sending unnecessary IPIs (see "IPI Reduction"), and
  69 even to ensure IPI acknowledgements are waited upon (see "Waiting for
  70 Acknowledgements").  The following modes are defined:
  71
  72 OUTSIDE_GUEST_MODE
  73
  74   The VCPU thread is outside guest mode.
  75
  76 IN_GUEST_MODE
  77
  78   The VCPU thread is in guest mode.
  79
  80 EXITING_GUEST_MODE
  81
  82   The VCPU thread is transitioning from IN_GUEST_MODE to
  83   OUTSIDE_GUEST_MODE.
  84
  85 READING_SHADOW_PAGE_TABLES
  86
  87   The VCPU thread is outside guest mode, but it wants the sender of
  88   certain VCPU requests, namely KVM_REQ_TLB_FLUSH, to wait until the VCPU
  89   thread is done reading the page tables.
  90
  91 VCPU Request Internals
  92 ======================
  93
  94 VCPU requests are simply bit indices of the ``vcpu->requests`` bitmap.
  95 This means general bitops, like those documented in [atomic-ops]_ could
  96 also be used, e.g. ::
  97
  98   clear_bit(KVM_REQ_UNHALT & KVM_REQUEST_MASK, &vcpu->requests);
  99
 100 However, VCPU request users should refrain from doing so, as it would
 101 break the abstraction.  The first 8 bits are reserved for architecture
 102 independent requests, all additional bits are available for architecture
 103 dependent requests.
 104
 105 Architecture Independent Requests
 106 ---------------------------------
 107
 108 KVM_REQ_TLB_FLUSH
 109
 110   KVM's common MMU notifier may need to flush all of a guest's TLB
 111   entries, calling kvm_flush_remote_tlbs() to do so.  Architectures that
 112   choose to use the common kvm_flush_remote_tlbs() implementation will
 113   need to handle this VCPU request.
 114
 115 KVM_REQ_VM_DEAD
 116
 117   This request informs all VCPUs that the VM is dead and unusable, e.g. due to
 118   fatal error or because the VM's state has been intentionally destroyed.
 119
 120 KVM_REQ_UNBLOCK
 121
 122   This request informs the vCPU to exit kvm_vcpu_block.  It is used for
 123   example from timer handlers that run on the host on behalf of a vCPU,
 124   or in order to update the interrupt routing and ensure that assigned
 125   devices will wake up the vCPU.
 126
 127 KVM_REQ_UNHALT
 128
 129   This request may be made from the KVM common function kvm_vcpu_block(),
 130   which is used to emulate an instruction that causes a CPU to halt until
 131   one of an architectural specific set of events and/or interrupts is
 132   received (determined by checking kvm_arch_vcpu_runnable()).  When that
 133   event or interrupt arrives kvm_vcpu_block() makes the request.  This is
 134   in contrast to when kvm_vcpu_block() returns due to any other reason,
 135   such as a pending signal, which does not indicate the VCPU's halt
 136   emulation should stop, and therefore does not make the request.
 137
 138 KVM_REQ_OUTSIDE_GUEST_MODE
 139
 140   This "request" ensures the target vCPU has exited guest mode prior to the
 141   sender of the request continuing on.  No action needs be taken by the target,
 142   and so no request is actually logged for the target.  This request is similar
 143   to a "kick", but unlike a kick it guarantees the vCPU has actually exited
 144   guest mode.  A kick only guarantees the vCPU will exit at some point in the
 145   future, e.g. a previous kick may have started the process, but there's no
 146   guarantee the to-be-kicked vCPU has fully exited guest mode.
 147
 148 KVM_REQUEST_MASK
 149 ----------------
 150
 151 VCPU requests should be masked by KVM_REQUEST_MASK before using them with
 152 bitops.  This is because only the lower 8 bits are used to represent the
 153 request's number.  The upper bits are used as flags.  Currently only two
 154 flags are defined.
 155
 156 VCPU Request Flags
 157 ------------------
 158
 159 KVM_REQUEST_NO_WAKEUP
 160
 161   This flag is applied to requests that only need immediate attention
 162   from VCPUs running in guest mode.  That is, sleeping VCPUs do not need
 163   to be awaken for these requests.  Sleeping VCPUs will handle the
 164   requests when they are awaken later for some other reason.
 165
 166 KVM_REQUEST_WAIT
 167
 168   When requests with this flag are made with kvm_make_all_cpus_request(),
 169   then the caller will wait for each VCPU to acknowledge its IPI before
 170   proceeding.  This flag only applies to VCPUs that would receive IPIs.
 171   If, for example, the VCPU is sleeping, so no IPI is necessary, then
 172   the requesting thread does not wait.  This means that this flag may be
 173   safely combined with KVM_REQUEST_NO_WAKEUP.  See "Waiting for
 174   Acknowledgements" for more information about requests with
 175   KVM_REQUEST_WAIT.
 176
 177 VCPU Requests with Associated State
 178 ===================================
 179
 180 Requesters that want the receiving VCPU to handle new state need to ensure
 181 the newly written state is observable to the receiving VCPU thread's CPU
 182 by the time it observes the request.  This means a write memory barrier
 183 must be inserted after writing the new state and before setting the VCPU
 184 request bit.  Additionally, on the receiving VCPU thread's side, a
 185 corresponding read barrier must be inserted after reading the request bit
 186 and before proceeding to read the new state associated with it.  See
 187 scenario 3, Message and Flag, of [lwn-mb]_ and the kernel documentation
 188 [memory-barriers]_.
 189
 190 The pair of functions, kvm_check_request() and kvm_make_request(), provide
 191 the memory barriers, allowing this requirement to be handled internally by
 192 the API.
 193
 194 Ensuring Requests Are Seen
 195 ==========================
 196
 197 When making requests to VCPUs, we want to avoid the receiving VCPU
 198 executing in guest mode for an arbitrary long time without handling the
 199 request.  We can be sure this won't happen as long as we ensure the VCPU
 200 thread checks kvm_request_pending() before entering guest mode and that a
 201 kick will send an IPI to force an exit from guest mode when necessary.
 202 Extra care must be taken to cover the period after the VCPU thread's last
 203 kvm_request_pending() check and before it has entered guest mode, as kick
 204 IPIs will only trigger guest mode exits for VCPU threads that are in guest
 205 mode or at least have already disabled interrupts in order to prepare to
 206 enter guest mode.  This means that an optimized implementation (see "IPI
 207 Reduction") must be certain when it's safe to not send the IPI.  One
 208 solution, which all architectures except s390 apply, is to:
 209
 210 - set ``vcpu->mode`` to IN_GUEST_MODE between disabling the interrupts and
 211   the last kvm_request_pending() check;
 212 - enable interrupts atomically when entering the guest.
 213
 214 This solution also requires memory barriers to be placed carefully in both
 215 the requesting thread and the receiving VCPU.  With the memory barriers we
 216 can exclude the possibility of a VCPU thread observing
 217 !kvm_request_pending() on its last check and then not receiving an IPI for
 218 the next request made of it, even if the request is made immediately after
 219 the check.  This is done by way of the Dekker memory barrier pattern
 220 (scenario 10 of [lwn-mb]_).  As the Dekker pattern requires two variables,
 221 this solution pairs ``vcpu->mode`` with ``vcpu->requests``.  Substituting
 222 them into the pattern gives::
 223
 224   CPU1                                    CPU2
 225   =================                       =================
 226   local_irq_disable();
 227   WRITE_ONCE(vcpu->mode, IN_GUEST_MODE);  kvm_make_request(REQ, vcpu);
 228   smp_mb();                               smp_mb();
 229   if (kvm_request_pending(vcpu)) {        if (READ_ONCE(vcpu->mode) ==
 230                                               IN_GUEST_MODE) {
 231       ...abort guest entry...                 ...send IPI...
 232   }                                       }
 233
 234 As stated above, the IPI is only useful for VCPU threads in guest mode or
 235 that have already disabled interrupts.  This is why this specific case of
 236 the Dekker pattern has been extended to disable interrupts before setting
 237 ``vcpu->mode`` to IN_GUEST_MODE.  WRITE_ONCE() and READ_ONCE() are used to
 238 pedantically implement the memory barrier pattern, guaranteeing the
 239 compiler doesn't interfere with ``vcpu->mode``'s carefully planned
 240 accesses.
 241
 242 IPI Reduction
 243 -------------
 244
 245 As only one IPI is needed to get a VCPU to check for any/all requests,
 246 then they may be coalesced.  This is easily done by having the first IPI
 247 sending kick also change the VCPU mode to something !IN_GUEST_MODE.  The
 248 transitional state, EXITING_GUEST_MODE, is used for this purpose.
 249
 250 Waiting for Acknowledgements
 251 ----------------------------
 252
 253 Some requests, those with the KVM_REQUEST_WAIT flag set, require IPIs to
 254 be sent, and the acknowledgements to be waited upon, even when the target
 255 VCPU threads are in modes other than IN_GUEST_MODE.  For example, one case
 256 is when a target VCPU thread is in READING_SHADOW_PAGE_TABLES mode, which
 257 is set after disabling interrupts.  To support these cases, the
 258 KVM_REQUEST_WAIT flag changes the condition for sending an IPI from
 259 checking that the VCPU is IN_GUEST_MODE to checking that it is not
 260 OUTSIDE_GUEST_MODE.
 261
 262 Request-less VCPU Kicks
 263 -----------------------
 264
 265 As the determination of whether or not to send an IPI depends on the
 266 two-variable Dekker memory barrier pattern, then it's clear that
 267 request-less VCPU kicks are almost never correct.  Without the assurance
 268 that a non-IPI generating kick will still result in an action by the
 269 receiving VCPU, as the final kvm_request_pending() check does for
 270 request-accompanying kicks, then the kick may not do anything useful at
 271 all.  If, for instance, a request-less kick was made to a VCPU that was
 272 just about to set its mode to IN_GUEST_MODE, meaning no IPI is sent, then
 273 the VCPU thread may continue its entry without actually having done
 274 whatever it was the kick was meant to initiate.
 275
 276 One exception is x86's posted interrupt mechanism.  In this case, however,
 277 even the request-less VCPU kick is coupled with the same
 278 local_irq_disable() + smp_mb() pattern described above; the ON bit
 279 (Outstanding Notification) in the posted interrupt descriptor takes the
 280 role of ``vcpu->requests``.  When sending a posted interrupt, PIR.ON is
 281 set before reading ``vcpu->mode``; dually, in the VCPU thread,
 282 vmx_sync_pir_to_irr() reads PIR after setting ``vcpu->mode`` to
 283 IN_GUEST_MODE.
 284
 285 Additional Considerations
 286 =========================
 287
 288 Sleeping VCPUs
 289 --------------
 290
 291 VCPU threads may need to consider requests before and/or after calling
 292 functions that may put them to sleep, e.g. kvm_vcpu_block().  Whether they
 293 do or not, and, if they do, which requests need consideration, is
 294 architecture dependent.  kvm_vcpu_block() calls kvm_arch_vcpu_runnable()
 295 to check if it should awaken.  One reason to do so is to provide
 296 architectures a function where requests may be checked if necessary.
 297
 298 Clearing Requests
 299 -----------------
 300
 301 Generally it only makes sense for the receiving VCPU thread to clear a
 302 request.  However, in some circumstances, such as when the requesting
 303 thread and the receiving VCPU thread are executed serially, such as when
 304 they are the same thread, or when they are using some form of concurrency
 305 control to temporarily execute synchronously, then it's possible to know
 306 that the request may be cleared immediately, rather than waiting for the
 307 receiving VCPU thread to handle the request in VCPU RUN.  The only current
 308 examples of this are kvm_vcpu_block() calls made by VCPUs to block
 309 themselves.  A possible side-effect of that call is to make the
 310 KVM_REQ_UNHALT request, which may then be cleared immediately when the
 311 VCPU returns from the call.
 312
 313 References
 314 ==========
 315
 316 .. [atomic-ops] Documentation/atomic_bitops.txt and Documentation/atomic_t.txt
 317 .. [memory-barriers] Documentation/memory-barriers.txt
 318 .. [lwn-mb] https://lwn.net/Articles/573436/