kernel/drivers/misc/vmw_vmci/vmci_route.c

   1 /*
   2  * VMware VMCI Driver
   3  *
   4  * Copyright (C) 2012 VMware, Inc. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation version 2 and no later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include <linux/vmw_vmci_defs.h>
  17 #include <linux/vmw_vmci_api.h>
  18
  19 #include "vmci_context.h"
  20 #include "vmci_driver.h"
  21 #include "vmci_route.h"
  22
  23 /*
  24  * Make a routing decision for the given source and destination handles.
  25  * This will try to determine the route using the handles and the available
  26  * devices.  Will set the source context if it is invalid.
  27  */
  28 int vmci_route(struct vmci_handle *src,
  29                const struct vmci_handle *dst,
  30                bool from_guest,
  31                enum vmci_route *route)
  32 {
  33         bool has_host_device = vmci_host_code_active();
  34         bool has_guest_device = vmci_guest_code_active();
  35
  36         *route = VMCI_ROUTE_NONE;
  37
  38         /*
  39          * "from_guest" is only ever set to true by
  40          * IOCTL_VMCI_DATAGRAM_SEND (or by the vmkernel equivalent),
  41          * which comes from the VMX, so we know it is coming from a
  42          * guest.
  43          *
  44          * To avoid inconsistencies, test these once.  We will test
  45          * them again when we do the actual send to ensure that we do
  46          * not touch a non-existent device.
  47          */
  48
  49         /* Must have a valid destination context. */
  50         if (VMCI_INVALID_ID == dst->context)
  51                 return VMCI_ERROR_INVALID_ARGS;
  52
  53         /* Anywhere to hypervisor. */
  54         if (VMCI_HYPERVISOR_CONTEXT_ID == dst->context) {
  55
  56                 /*
  57                  * If this message already came from a guest then we
  58                  * cannot send it to the hypervisor.  It must come
  59                  * from a local client.
  60                  */
  61                 if (from_guest)
  62                         return VMCI_ERROR_DST_UNREACHABLE;
  63
  64                 /*
  65                  * We must be acting as a guest in order to send to
  66                  * the hypervisor.
  67                  */
  68                 if (!has_guest_device)
  69                         return VMCI_ERROR_DEVICE_NOT_FOUND;
  70
  71                 /* And we cannot send if the source is the host context. */
  72                 if (VMCI_HOST_CONTEXT_ID == src->context)
  73                         return VMCI_ERROR_INVALID_ARGS;
  74
  75                 /*
  76                  * If the client passed the ANON source handle then
  77                  * respect it (both context and resource are invalid).
  78                  * However, if they passed only an invalid context,
  79                  * then they probably mean ANY, in which case we
  80                  * should set the real context here before passing it
  81                  * down.
  82                  */
  83                 if (VMCI_INVALID_ID == src->context &&
  84                     VMCI_INVALID_ID != src->resource)
  85                         src->context = vmci_get_context_id();
  86
  87                 /* Send from local client down to the hypervisor. */
  88                 *route = VMCI_ROUTE_AS_GUEST;
  89                 return VMCI_SUCCESS;
  90         }
  91
  92         /* Anywhere to local client on host. */
  93         if (VMCI_HOST_CONTEXT_ID == dst->context) {
  94                 /*
  95                  * If it is not from a guest but we are acting as a
  96                  * guest, then we need to send it down to the host.
  97                  * Note that if we are also acting as a host then this
  98                  * will prevent us from sending from local client to
  99                  * local client, but we accept that restriction as a
 100                  * way to remove any ambiguity from the host context.
 101                  */
 102                 if (src->context == VMCI_HYPERVISOR_CONTEXT_ID) {
 103                         /*
 104                          * If the hypervisor is the source, this is
 105                          * host local communication. The hypervisor
 106                          * may send vmci event datagrams to the host
 107                          * itself, but it will never send datagrams to
 108                          * an "outer host" through the guest device.
 109                          */
 110
 111                         if (has_host_device) {
 112                                 *route = VMCI_ROUTE_AS_HOST;
 113                                 return VMCI_SUCCESS;
 114                         } else {
 115                                 return VMCI_ERROR_DEVICE_NOT_FOUND;
 116                         }
 117                 }
 118
 119                 if (!from_guest && has_guest_device) {
 120                         /* If no source context then use the current. */
 121                         if (VMCI_INVALID_ID == src->context)
 122                                 src->context = vmci_get_context_id();
 123
 124                         /* Send it from local client down to the host. */
 125                         *route = VMCI_ROUTE_AS_GUEST;
 126                         return VMCI_SUCCESS;
 127                 }
 128
 129                 /*
 130                  * Otherwise we already received it from a guest and
 131                  * it is destined for a local client on this host, or
 132                  * it is from another local client on this host.  We
 133                  * must be acting as a host to service it.
 134                  */
 135                 if (!has_host_device)
 136                         return VMCI_ERROR_DEVICE_NOT_FOUND;
 137
 138                 if (VMCI_INVALID_ID == src->context) {
 139                         /*
 140                          * If it came from a guest then it must have a
 141                          * valid context.  Otherwise we can use the
 142                          * host context.
 143                          */
 144                         if (from_guest)
 145                                 return VMCI_ERROR_INVALID_ARGS;
 146
 147                         src->context = VMCI_HOST_CONTEXT_ID;
 148                 }
 149
 150                 /* Route to local client. */
 151                 *route = VMCI_ROUTE_AS_HOST;
 152                 return VMCI_SUCCESS;
 153         }
 154
 155         /*
 156          * If we are acting as a host then this might be destined for
 157          * a guest.
 158          */
 159         if (has_host_device) {
 160                 /* It will have a context if it is meant for a guest. */
 161                 if (vmci_ctx_exists(dst->context)) {
 162                         if (VMCI_INVALID_ID == src->context) {
 163                                 /*
 164                                  * If it came from a guest then it
 165                                  * must have a valid context.
 166                                  * Otherwise we can use the host
 167                                  * context.
 168                                  */
 169
 170                                 if (from_guest)
 171                                         return VMCI_ERROR_INVALID_ARGS;
 172
 173                                 src->context = VMCI_HOST_CONTEXT_ID;
 174                         } else if (VMCI_CONTEXT_IS_VM(src->context) &&
 175                                    src->context != dst->context) {
 176                                 /*
 177                                  * VM to VM communication is not
 178                                  * allowed. Since we catch all
 179                                  * communication destined for the host
 180                                  * above, this must be destined for a
 181                                  * VM since there is a valid context.
 182                                  */
 183
 184                                 return VMCI_ERROR_DST_UNREACHABLE;
 185                         }
 186
 187                         /* Pass it up to the guest. */
 188                         *route = VMCI_ROUTE_AS_HOST;
 189                         return VMCI_SUCCESS;
 190                 } else if (!has_guest_device) {
 191                         /*
 192                          * The host is attempting to reach a CID
 193                          * without an active context, and we can't
 194                          * send it down, since we have no guest
 195                          * device.
 196                          */
 197
 198                         return VMCI_ERROR_DST_UNREACHABLE;
 199                 }
 200         }
 201
 202         /*
 203          * We must be a guest trying to send to another guest, which means
 204          * we need to send it down to the host. We do not filter out VM to
 205          * VM communication here, since we want to be able to use the guest
 206          * driver on older versions that do support VM to VM communication.
 207          */
 208         if (!has_guest_device) {
 209                 /*
 210                  * Ending up here means we have neither guest nor host
 211                  * device.
 212                  */
 213                 return VMCI_ERROR_DEVICE_NOT_FOUND;
 214         }
 215
 216         /* If no source context then use the current context. */
 217         if (VMCI_INVALID_ID == src->context)
 218                 src->context = vmci_get_context_id();
 219
 220         /*
 221          * Send it from local client down to the host, which will
 222          * route it to the other guest for us.
 223          */
 224         *route = VMCI_ROUTE_AS_GUEST;
 225         return VMCI_SUCCESS;
 226 }