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 */
28int 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}
227