Commit | Line | Data |
---|---|---|
e76ffea3 GZ |
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 | } |