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