1 /*
2 * Copyright (c) 2016-2021 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 #include <skywalk/os_skywalk_private.h>
30 #include <skywalk/nexus/flowswitch/nx_flowswitch.h>
31 #include <skywalk/nexus/flowswitch/fsw_var.h>
32
33 /* automatically register a netagent at constructor time */
34 static int fsw_netagent = 1;
35
36 #if (DEVELOPMENT || DEBUG)
37 SYSCTL_INT(_kern_skywalk_flowswitch, OID_AUTO, netagent,
38 CTLFLAG_RW | CTLFLAG_LOCKED, &fsw_netagent, 0, "");
39 #endif /* !DEVELOPMENT && !DEBUG */
40
41 static packet_svc_class_t
fsw_netagent_tc2sc(uint32_t tc,uint32_t * scp)42 fsw_netagent_tc2sc(uint32_t tc, uint32_t *scp)
43 {
44 uint32_t sc;
45 int ret = 0;
46
47 switch (tc) {
48 case SO_TC_BK_SYS:
49 sc = PKT_SC_BK_SYS;
50 break;
51 case SO_TC_BK:
52 sc = PKT_SC_BK;
53 break;
54 case SO_TC_BE:
55 sc = PKT_SC_BE;
56 break;
57 case SO_TC_RD:
58 sc = PKT_SC_RD;
59 break;
60 case SO_TC_OAM:
61 sc = PKT_SC_OAM;
62 break;
63 case SO_TC_AV:
64 sc = PKT_SC_AV;
65 break;
66 case SO_TC_RV:
67 sc = PKT_SC_RV;
68 break;
69 case SO_TC_VI:
70 sc = PKT_SC_VI;
71 break;
72 case SO_TC_NETSVC_SIG:
73 sc = PKT_SC_SIG;
74 break;
75 case SO_TC_VO:
76 sc = PKT_SC_VO;
77 break;
78 case SO_TC_CTL:
79 sc = PKT_SC_CTL;
80 break;
81 default:
82 sc = PKT_SC_BE;
83 ret = -1;
84 break;
85 }
86
87 *scp = sc;
88 return ret;
89 }
90
91 static int
fsw_netagent_flow_add(struct nx_flowswitch * fsw,uuid_t flow_uuid,pid_t pid,void * context,struct necp_client_nexus_parameters * cparams,void ** results,size_t * results_length)92 fsw_netagent_flow_add(struct nx_flowswitch *fsw, uuid_t flow_uuid, pid_t pid,
93 void *context, struct necp_client_nexus_parameters *cparams,
94 void **results, size_t *results_length)
95 {
96 struct nx_flow_req req;
97 struct flow_owner *fo = NULL;
98 size_t assign_message_length = 0;
99 void *assign_message = NULL;
100 struct necp_client_endpoint local_endpoint;
101 struct necp_client_endpoint remote_endpoint;
102 int error;
103
104 ASSERT(cparams != NULL);
105 ASSERT(results != NULL && *results == NULL);
106 ASSERT(results_length != NULL && *results_length == 0);
107
108 bzero(&req, sizeof(req));
109 req.nfr_nx_port = NEXUS_PORT_ANY;
110 req.nfr_flowadv_idx = FLOWADV_IDX_NONE;
111 bcopy((void *)&cparams->local_addr, (void *)&req.nfr_saddr,
112 sizeof(cparams->local_addr));
113 bcopy((void *)&cparams->remote_addr, (void *)&req.nfr_daddr,
114 sizeof(cparams->remote_addr));
115 req.nfr_flags = (NXFLOWREQF_TRACK | NXFLOWREQF_FLOWADV);
116 req.nfr_ip_protocol = cparams->ip_protocol;
117 req.nfr_transport_protocol = cparams->transport_protocol;
118 uuid_copy(req.nfr_flow_uuid, flow_uuid);
119 uuid_copy(req.nfr_euuid, cparams->euuid);
120 req.nfr_epid = cparams->epid;
121 req.nfr_policy_id = (uint32_t)cparams->policy_id;
122
123 if (fsw_netagent_tc2sc(cparams->traffic_class,
124 &req.nfr_svc_class) != 0) {
125 error = EINVAL;
126 goto done;
127 }
128
129 if (cparams->allow_qos_marking) {
130 req.nfr_flags |= NXFLOWREQF_QOS_MARKING;
131 }
132 if (cparams->override_address_selection) {
133 req.nfr_flags |= NXFLOWREQF_OVERRIDE_ADDRESS_SELECTION;
134 }
135 if (cparams->use_stable_address) {
136 req.nfr_flags |= NXFLOWREQF_USE_STABLE_ADDRESS;
137 }
138
139 req.nfr_context = context;
140 req.nfr_pid = pid;
141 req.nfr_port_reservation = cparams->port_reservation;
142
143 ASSERT(req.nfr_flags & NXFLOWREQF_FLOWADV);
144 fo = fsw_flow_add(fsw, &req, &error);
145 if (fo == NULL) {
146 ASSERT(error != 0);
147 ASSERT(req.nfr_flow_stats == NULL);
148 goto done;
149 }
150
151 ASSERT(error == 0);
152 ASSERT(req.nfr_nx_port != NEXUS_PORT_ANY);
153 ASSERT(!uuid_is_null(fo->fo_key));
154 ASSERT(req.nfr_flowadv_idx != FLOWADV_IDX_NONE);
155 ASSERT(req.nfr_flow_stats != NULL);
156 ASSERT(flow_stats_refcnt(req.nfr_flow_stats) == 2);
157
158 bzero(&local_endpoint, sizeof(local_endpoint));
159 bzero(&remote_endpoint, sizeof(remote_endpoint));
160
161 bcopy((void *)&req.nfr_saddr, (void *)&local_endpoint.u.sin6,
162 sizeof(req.nfr_saddr));
163 bcopy((void *)&req.nfr_daddr, (void *)&remote_endpoint.u.sin6,
164 sizeof(req.nfr_daddr));
165
166 assign_message =
167 necp_create_nexus_assign_message(fsw->fsw_nx->nx_uuid,
168 req.nfr_nx_port, fo->fo_key, sizeof(fo->fo_key),
169 &local_endpoint, &remote_endpoint, NULL, req.nfr_flowadv_idx,
170 req.nfr_flow_stats, &assign_message_length);
171
172 if (assign_message != NULL) {
173 req.nfr_flow_stats = NULL;
174 ASSERT(error == 0);
175 *results = assign_message;
176 *results_length = assign_message_length;
177 } else {
178 error = ENOMEM;
179 }
180
181 done:
182 #if SK_LOG
183 if (__improbable((sk_verbose & SK_VERB_FLOW) != 0)) {
184 uuid_string_t uuidstr;
185 SK_DF(SK_VERB_FLOW, "pid %d connect flow_uuid %s nx_port %d "
186 "(err %d)", pid, sk_uuid_unparse(flow_uuid, uuidstr),
187 (int)req.nfr_nx_port, error);
188 }
189 #endif /* SK_LOG */
190 if (error != 0) {
191 ASSERT(*results == NULL);
192 ASSERT(*results_length == 0);
193 if (assign_message != NULL) {
194 kfree_data(assign_message, assign_message_length);
195 assign_message = NULL;
196 }
197 if (fo != NULL) {
198 req.nfr_pid = pid;
199 fsw_flow_del(fsw, &req, TRUE, NULL);
200 }
201 if (req.nfr_flow_stats != NULL) {
202 flow_stats_release(req.nfr_flow_stats);
203 req.nfr_flow_stats = NULL;
204 }
205 }
206
207 return error;
208 }
209
210 static int
fsw_netagent_flow_del(struct nx_flowswitch * fsw,uuid_t flow_uuid,pid_t pid,bool nolinger,void * context,void * params)211 fsw_netagent_flow_del(struct nx_flowswitch *fsw, uuid_t flow_uuid, pid_t pid,
212 bool nolinger, void *context, void *params)
213 {
214 struct nx_flow_req req;
215 int error;
216
217 bzero(&req, sizeof(req));
218 uuid_copy(req.nfr_flow_uuid, flow_uuid);
219 req.nfr_proc = NULL;
220 req.nfr_pid = pid;
221 req.nfr_context = context;
222
223 error = fsw_flow_del(fsw, &req, nolinger, params);
224
225 #if SK_LOG
226 if (__improbable((sk_verbose & SK_VERB_FLOW) != 0)) {
227 uuid_string_t uuidstr;
228 SK_DF(SK_VERB_FLOW, "pid %d flow_uuid %s (err %d)",
229 pid, sk_uuid_unparse(flow_uuid, uuidstr), error);
230 }
231 #endif /* SK_LOG */
232
233 return error;
234 }
235
236 static int
fsw_netagent_event(u_int8_t event,uuid_t flow_uuid,pid_t pid,void * context,void * ctx,struct necp_client_agent_parameters * cparams,void ** results,size_t * results_length)237 fsw_netagent_event(u_int8_t event, uuid_t flow_uuid, pid_t pid, void *context,
238 void *ctx, struct necp_client_agent_parameters *cparams, void **results,
239 size_t *results_length)
240 {
241 struct nx_flowswitch *fsw;
242 int error = 0;
243
244 ASSERT(!uuid_is_null(flow_uuid));
245
246 fsw = (struct nx_flowswitch *)ctx;
247 ASSERT(fsw != NULL);
248
249 switch (event) {
250 case NETAGENT_EVENT_NEXUS_FLOW_INSERT:
251 /* these are required for this event */
252 ASSERT(cparams != NULL);
253 ASSERT(results != NULL);
254 ASSERT(results_length != NULL);
255 *results = NULL;
256 *results_length = 0;
257 error = fsw_netagent_flow_add(fsw, flow_uuid, pid, context,
258 &cparams->u.nexus_request, results, results_length);
259 break;
260
261 case NETAGENT_EVENT_NEXUS_FLOW_REMOVE:
262 case NETAGENT_EVENT_NEXUS_FLOW_ABORT:
263 /*
264 * A flow can be removed gracefully (FLOW_REMOVE) by
265 * the client, in which case we don't need to have it
266 * linger around to hold the namespace. If the process
267 * crashed or if it's suspended, then we treat that
268 * as the abort case (FLOW_ABORT) where we'll hold on
269 * to the namespace if needed.
270 */
271 error = fsw_netagent_flow_del(fsw, flow_uuid, pid,
272 (event == NETAGENT_EVENT_NEXUS_FLOW_REMOVE), context,
273 cparams);
274 break;
275
276 default:
277 /* events not handled */
278 return 0;
279 }
280
281 return error;
282 }
283
284 int
fsw_netagent_register(struct nx_flowswitch * fsw,struct ifnet * ifp)285 fsw_netagent_register(struct nx_flowswitch *fsw, struct ifnet *ifp)
286 {
287 struct netagent_nexus_agent agent;
288 int error = 0;
289
290 _CASSERT(FLOWADV_IDX_NONE == UINT32_MAX);
291 _CASSERT(NECP_FLOWADV_IDX_INVALID == FLOWADV_IDX_NONE);
292
293 if (!fsw_netagent) {
294 return 0;
295 }
296
297 fsw->fsw_agent_session = netagent_create(fsw_netagent_event, fsw);
298 if (fsw->fsw_agent_session == NULL) {
299 return ENOMEM;
300 }
301
302 bzero(&agent, sizeof(agent));
303 uuid_generate_random(agent.agent.netagent_uuid);
304 uuid_copy(fsw->fsw_agent_uuid, agent.agent.netagent_uuid);
305 (void) snprintf(agent.agent.netagent_domain,
306 sizeof(agent.agent.netagent_domain), "%s", "Skywalk");
307 (void) snprintf(agent.agent.netagent_type,
308 sizeof(agent.agent.netagent_type), "%s", "FlowSwitch");
309 (void) snprintf(agent.agent.netagent_desc,
310 sizeof(agent.agent.netagent_desc), "%s", "Userspace Networking");
311 agent.agent.netagent_flags = NETAGENT_FLAG_ACTIVE;
312 if (ifnet_needs_fsw_transport_netagent(ifp)) {
313 agent.agent.netagent_flags |= (NETAGENT_FLAG_NEXUS_PROVIDER |
314 NETAGENT_FLAG_NEXUS_LISTENER);
315 }
316 if (ifnet_needs_fsw_ip_netagent(ifp)) {
317 ASSERT((sk_features & SK_FEATURE_PROTONS) != 0);
318 agent.agent.netagent_flags |= (NETAGENT_FLAG_CUSTOM_IP_NEXUS |
319 NETAGENT_FLAG_NEXUS_LISTENER);
320 }
321 agent.agent.netagent_data_size = sizeof(struct netagent_nexus);
322 agent.nexus_data.frame_type = NETAGENT_NEXUS_FRAME_TYPE_INTERNET;
323 agent.nexus_data.endpoint_assignment_type =
324 NETAGENT_NEXUS_ENDPOINT_TYPE_ADDRESS;
325 agent.nexus_data.endpoint_request_types[0] =
326 NETAGENT_NEXUS_ENDPOINT_TYPE_ADDRESS;
327 agent.nexus_data.endpoint_resolution_type_pairs[0] =
328 NETAGENT_NEXUS_ENDPOINT_TYPE_HOST;
329 agent.nexus_data.endpoint_resolution_type_pairs[1] =
330 NETAGENT_NEXUS_ENDPOINT_TYPE_ADDRESS;
331 agent.nexus_data.endpoint_resolution_type_pairs[2] =
332 NETAGENT_NEXUS_ENDPOINT_TYPE_BONJOUR;
333 agent.nexus_data.endpoint_resolution_type_pairs[3] =
334 NETAGENT_NEXUS_ENDPOINT_TYPE_HOST;
335 agent.nexus_data.endpoint_resolution_type_pairs[4] =
336 NETAGENT_NEXUS_ENDPOINT_TYPE_SRV;
337 agent.nexus_data.endpoint_resolution_type_pairs[5] =
338 NETAGENT_NEXUS_ENDPOINT_TYPE_HOST;
339 agent.nexus_data.nexus_max_buf_size =
340 fsw->fsw_nx->nx_prov->nxprov_params->nxp_buf_size;
341 agent.nexus_data.nexus_flags |=
342 (NETAGENT_NEXUS_FLAG_SUPPORTS_USER_PACKET_POOL |
343 NETAGENT_NEXUS_FLAG_ASSERT_UNSUPPORTED);
344
345 error = netagent_register(fsw->fsw_agent_session, &agent.agent);
346 if (error != 0) {
347 goto fail_netagent_register;
348 }
349
350 error = if_add_netagent(ifp, fsw->fsw_agent_uuid);
351 if (error != 0) {
352 goto fail_netagent_add;
353 }
354 fsw->fsw_state_flags |= FSW_STATEF_NETAGENT_ADDED;
355 if (if_is_fsw_netagent_enabled()) {
356 fsw->fsw_state_flags |= FSW_STATEF_NETAGENT_ENABLED;
357 }
358
359 return 0;
360
361 fail_netagent_add:
362 netagent_unregister(fsw->fsw_agent_session);
363
364 fail_netagent_register:
365 netagent_destroy(fsw->fsw_agent_session);
366 fsw->fsw_agent_session = NULL;
367 uuid_clear(fsw->fsw_agent_uuid);
368
369 return error;
370 }
371
372 void
fsw_netagent_unregister(struct nx_flowswitch * fsw,struct ifnet * ifp)373 fsw_netagent_unregister(struct nx_flowswitch *fsw, struct ifnet *ifp)
374 {
375 if (!uuid_is_null(fsw->fsw_agent_uuid)) {
376 if_delete_netagent(ifp, fsw->fsw_agent_uuid);
377 }
378
379 if (fsw->fsw_agent_session != NULL) {
380 netagent_destroy(fsw->fsw_agent_session);
381 fsw->fsw_agent_session = NULL;
382 uuid_clear(fsw->fsw_agent_uuid);
383 }
384 }
385