1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
4 * We are making the OpenFlow specification and associated documentation
5 * (Software) available for public use and benefit with the expectation
6 * that others will use, modify and enhance the Software and contribute
7 * those enhancements back to the community. However, since we would
8 * like to make the Software available for broadest use, with as few
9 * restrictions as possible permission is hereby granted, free of
10 * charge, to any person obtaining a copy of this Software to deal in
11 * the Software under the copyrights without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sublicense, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice shall be
18 * included in all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
24 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 * The name and trademarks of copyright holder(s) may NOT be used in
30 * advertising or publicity pertaining to the Software or any
31 * derivatives without specific, written prior permission.
39 #include <netinet/in.h>
45 #include "ofp-print.h"
46 #include "openflow-netlink.h"
53 #define THIS_MODULE VLM_dpif
55 /* The Generic Netlink family number used for OpenFlow. */
56 static int openflow_family;
58 static int lookup_openflow_multicast_group(int dp_idx, int *multicast_group);
59 static int send_mgmt_command(struct dpif *, int command,
62 /* Opens the local datapath numbered 'dp_idx', initializing 'dp'. If
63 * 'subscribe' is true, listens for asynchronous messages (packet-in, etc.)
64 * from the datapath; otherwise, 'dp' will receive only replies to explicitly
65 * initiated requests. */
67 dpif_open(int dp_idx, bool subscribe, struct dpif *dp)
70 int multicast_group = 0;
73 retval = nl_lookup_genl_family(DP_GENL_FAMILY_NAME, &openflow_family);
79 retval = lookup_openflow_multicast_group(dp_idx, &multicast_group);
85 /* Specify a large so_rcvbuf size because we occasionally need to be able
86 * to retrieve large collections of flow records. */
87 retval = nl_sock_create(NETLINK_GENERIC, multicast_group, 0,
88 4 * 1024u * 1024, &sock);
100 dpif_close(struct dpif *dp)
102 nl_sock_destroy(dp->sock);
105 static const struct nl_policy openflow_policy[] = {
106 [DP_GENL_A_DP_IDX] = { .type = NL_A_U32 },
107 [DP_GENL_A_OPENFLOW] = { .type = NL_A_UNSPEC,
108 .min_len = sizeof(struct ofp_header),
109 .max_len = OFP_MAXLEN },
112 /* Tries to receive an openflow message from the kernel on 'sock'. If
113 * successful, stores the received message into '*msgp' and returns 0. The
114 * caller is responsible for destroying the message with buffer_delete(). On
115 * failure, returns a positive errno value and stores a null pointer into
118 * Only Netlink messages with embedded OpenFlow messages are accepted. Other
119 * Netlink messages provoke errors.
121 * If 'wait' is true, dpif_recv_openflow waits for a message to be ready;
122 * otherwise, returns EAGAIN if the 'sock' receive buffer is empty. */
124 dpif_recv_openflow(struct dpif *dp, struct buffer **bufferp,
127 struct nlattr *attrs[ARRAY_SIZE(openflow_policy)];
128 struct buffer *buffer;
129 struct ofp_header *oh;
135 retval = nl_sock_recv(dp->sock, &buffer, wait);
136 } while (retval == ENOBUFS || (!retval && nl_msg_nlmsgerr(buffer, NULL)));
138 if (retval != EAGAIN) {
139 VLOG_WARN("dpif_recv_openflow: %s", strerror(retval));
144 if (nl_msg_genlmsghdr(buffer) == NULL) {
145 VLOG_DBG("received packet too short for Generic Netlink");
148 if (nl_msg_nlmsghdr(buffer)->nlmsg_type != openflow_family) {
149 VLOG_DBG("received type (%"PRIu16") != openflow family (%d)",
150 nl_msg_nlmsghdr(buffer)->nlmsg_type, openflow_family);
154 if (!nl_policy_parse(buffer, openflow_policy, attrs,
155 ARRAY_SIZE(openflow_policy))) {
158 if (nl_attr_get_u32(attrs[DP_GENL_A_DP_IDX]) != dp->dp_idx) {
159 VLOG_WARN("received dp_idx (%"PRIu32") differs from expected (%d)",
160 nl_attr_get_u32(attrs[DP_GENL_A_DP_IDX]), dp->dp_idx);
164 oh = buffer->data = (void *) nl_attr_get(attrs[DP_GENL_A_OPENFLOW]);
165 buffer->size = nl_attr_get_size(attrs[DP_GENL_A_OPENFLOW]);
166 ofp_len = ntohs(oh->length);
167 if (ofp_len != buffer->size) {
168 VLOG_WARN("ofp_header.length %"PRIu16" != attribute length %zu\n",
169 ofp_len, buffer->size);
170 buffer->size = MIN(ofp_len, buffer->size);
176 buffer_delete(buffer);
180 /* Encapsulates 'msg', which must contain an OpenFlow message, in a Netlink
181 * message, and sends it to the OpenFlow kernel module via 'sock'.
183 * Returns 0 if successful, otherwise a positive errno value. If
184 * 'wait' is true, then the send will wait until buffer space is ready;
185 * otherwise, returns EAGAIN if the 'sock' send buffer is full.
187 * If the send is successful, then the kernel module will receive it, but there
188 * is no guarantee that any reply will not be dropped (see nl_sock_transact()
192 dpif_send_openflow(struct dpif *dp, struct buffer *buffer, bool wait)
196 uint32_t fixed_buffer[64 / 4];
202 buffer_use(&hdr, fixed_buffer, sizeof fixed_buffer);
203 nl_msg_put_genlmsghdr(&hdr, dp->sock, 32, openflow_family,
204 NLM_F_REQUEST, DP_GENL_C_OPENFLOW, 1);
205 nl_msg_put_u32(&hdr, DP_GENL_A_DP_IDX, dp->dp_idx);
206 nla = buffer_put_uninit(&hdr, sizeof nla);
207 nla->nla_len = sizeof nla + buffer->size;
208 nla->nla_type = DP_GENL_A_OPENFLOW;
209 pad_bytes = NLA_ALIGN(nla->nla_len) - nla->nla_len;
210 nl_msg_nlmsghdr(&hdr)->nlmsg_len = hdr.size + buffer->size + pad_bytes;
212 iov[0].iov_base = hdr.data;
213 iov[0].iov_len = hdr.size;
214 iov[1].iov_base = buffer->data;
215 iov[1].iov_len = buffer->size;
217 static char zeros[NLA_ALIGNTO];
219 iov[2].iov_base = zeros;
220 iov[2].iov_len = pad_bytes;
222 retval = nl_sock_sendv(dp->sock, iov, n_iov, false);
223 if (retval && retval != EAGAIN) {
224 VLOG_WARN("dpif_send_openflow: %s", strerror(retval));
229 /* Creates the datapath represented by 'dp'. Returns 0 if successful,
230 * otherwise a positive errno value. */
232 dpif_add_dp(struct dpif *dp)
234 return send_mgmt_command(dp, DP_GENL_C_ADD_DP, NULL);
237 /* Destroys the datapath represented by 'dp'. Returns 0 if successful,
238 * otherwise a positive errno value. */
240 dpif_del_dp(struct dpif *dp)
242 return send_mgmt_command(dp, DP_GENL_C_DEL_DP, NULL);
245 /* Adds the Ethernet device named 'netdev' to this datapath. Returns 0 if
246 * successful, otherwise a positive errno value. */
248 dpif_add_port(struct dpif *dp, const char *netdev)
250 return send_mgmt_command(dp, DP_GENL_C_ADD_PORT, netdev);
253 /* Removes the Ethernet device named 'netdev' from this datapath. Returns 0
254 * if successful, otherwise a positive errno value. */
256 dpif_del_port(struct dpif *dp, const char *netdev)
258 return send_mgmt_command(dp, DP_GENL_C_DEL_PORT, netdev);
261 static const struct nl_policy table_policy[] = {
262 [DP_GENL_A_NUMTABLES] = { .type = NL_A_U32 },
263 [DP_GENL_A_TABLE] = { .type = NL_A_UNSPEC },
266 /* Writes a description of 'dp''s tables to stdout. Returns 0 if successful,
267 * otherwise a positive errno value. */
269 dpif_dump_tables(struct dpif *dp)
271 struct buffer request, *reply;
272 struct nlattr *attrs[ARRAY_SIZE(table_policy)];
273 const struct ofp_table *tables;
278 buffer_init(&request, 0);
279 nl_msg_put_genlmsghdr(&request, dp->sock, 0, openflow_family,
280 NLM_F_REQUEST, DP_GENL_C_QUERY_TABLE, 1);
281 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp->dp_idx);
282 retval = nl_sock_transact(dp->sock, &request, &reply);
283 buffer_uninit(&request);
287 if (!nl_policy_parse(reply, table_policy, attrs,
288 ARRAY_SIZE(table_policy))) {
289 buffer_delete(reply);
293 tables = nl_attr_get(attrs[DP_GENL_A_TABLE]);
294 n_tables = (nl_attr_get_size(attrs[DP_GENL_A_TABLE])
295 / sizeof(struct ofp_table));
296 n_tables = MIN(n_tables, nl_attr_get_u32(attrs[DP_GENL_A_NUMTABLES]));
297 for (i = 0; i < n_tables; i++) {
298 const struct ofp_table *ot = &tables[i];
299 if (ot->header.version != 1 || ot->header.type != OFPT_TABLE) {
300 VLOG_DBG("bad table query response (%"PRIu8",%"PRIu8")",
301 ot->header.version, ot->header.type);
306 ofp_print_table(stdout, ot);
307 fprintf(stdout,"\n");
309 buffer_delete(reply);
314 static const struct nl_policy flow_policy[] = {
315 [DP_GENL_A_TABLEIDX] = { .type = NL_A_U16 },
316 [DP_GENL_A_NUMFLOWS] = { .type = NL_A_U32 },
317 [DP_GENL_A_FLOW] = { .type = NL_A_UNSPEC },
320 /* Writes a description of flows in the given 'table' in 'dp' to stdout. If
321 * 'match' is null, all flows in the table are written; otherwise, only
322 * matching flows are written. Returns 0 if successful, otherwise a positive
325 dpif_dump_flows(struct dpif *dp, int table, struct ofp_match *match)
327 struct buffer request, *reply;
328 struct ofp_flow_mod *ofm;
331 buffer_init(&request, 0);
332 nl_msg_put_genlmsghdr(&request, dp->sock, 0, openflow_family, NLM_F_REQUEST,
333 DP_GENL_C_QUERY_FLOW, 1);
334 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp->dp_idx);
335 nl_msg_put_u16(&request, DP_GENL_A_TABLEIDX, table);
336 ofm = nl_msg_put_unspec_uninit(&request, DP_GENL_A_FLOW, sizeof *ofm);
337 memset(ofm, 0, sizeof *ofm);
338 ofm->header.version = 1;
339 ofm->header.type = OFPT_FLOW_MOD;
340 ofm->header.length = htons(sizeof ofm);
344 ofm->match.wildcards = htons(OFPFW_ALL);
346 retval = nl_sock_transact(dp->sock, &request, &reply);
347 buffer_uninit(&request);
353 struct nlattr *attrs[ARRAY_SIZE(flow_policy)];
354 const struct ofp_flow_mod *flows, *ofm;
357 if (!nl_policy_parse(reply, flow_policy, attrs,
358 ARRAY_SIZE(flow_policy))) {
359 buffer_delete(reply);
362 n_flows = (nl_attr_get_size(attrs[DP_GENL_A_FLOW])
363 / sizeof(struct ofp_flow_mod));
364 n_flows = MIN(n_flows, nl_attr_get_u32(attrs[DP_GENL_A_NUMFLOWS]));
369 flows = nl_attr_get(attrs[DP_GENL_A_FLOW]);
370 for (ofm = flows; ofm < &flows[n_flows]; ofm++) {
371 if (ofm->header.version != 1){
372 VLOG_DBG("recv_dp_flow incorrect version");
373 buffer_delete(reply);
375 } else if (ofm->header.type != OFPT_FLOW_MOD) {
376 VLOG_DBG("recv_fp_flow bad return message type");
377 buffer_delete(reply);
381 ofp_print(stdout, ofm, sizeof *ofm, 1);
385 buffer_delete(reply);
386 retval = nl_sock_recv(dp->sock, &reply, true);
394 /* Tells dp to send num_packets up through netlink for benchmarking*/
396 dpif_benchmark_nl(struct dpif *dp, uint32_t num_packets, uint32_t packet_size)
398 struct buffer request;
401 buffer_init(&request, 0);
402 nl_msg_put_genlmsghdr(&request, dp->sock, 0, openflow_family,
403 NLM_F_REQUEST, DP_GENL_C_BENCHMARK_NL, 1);
404 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp->dp_idx);
405 nl_msg_put_u32(&request, DP_GENL_A_NPACKETS, num_packets);
406 nl_msg_put_u32(&request, DP_GENL_A_PSIZE, packet_size);
407 retval = nl_sock_send(dp->sock, &request, true);
408 buffer_uninit(&request);
413 static const struct nl_policy openflow_multicast_policy[] = {
414 [DP_GENL_A_DP_IDX] = { .type = NL_A_U32 },
415 [DP_GENL_A_MC_GROUP] = { .type = NL_A_U32 },
418 /* Looks up the Netlink multicast group used by datapath 'dp_idx'. If
419 * successful, stores the multicast group in '*multicast_group' and returns 0.
420 * Otherwise, returns a positve errno value. */
422 lookup_openflow_multicast_group(int dp_idx, int *multicast_group)
424 struct nl_sock *sock;
425 struct buffer request, *reply;
426 struct nlattr *attrs[ARRAY_SIZE(openflow_multicast_policy)];
429 retval = nl_sock_create(NETLINK_GENERIC, 0, 0, 0, &sock);
433 buffer_init(&request, 0);
434 nl_msg_put_genlmsghdr(&request, sock, 0, openflow_family, NLM_F_REQUEST,
435 DP_GENL_C_QUERY_DP, 1);
436 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp_idx);
437 retval = nl_sock_transact(sock, &request, &reply);
438 buffer_uninit(&request);
440 nl_sock_destroy(sock);
443 if (!nl_policy_parse(reply, openflow_multicast_policy, attrs,
444 ARRAY_SIZE(openflow_multicast_policy))) {
445 nl_sock_destroy(sock);
446 buffer_delete(reply);
449 *multicast_group = nl_attr_get_u32(attrs[DP_GENL_A_MC_GROUP]);
450 nl_sock_destroy(sock);
451 buffer_delete(reply);
456 /* Sends the given 'command' to datapath 'dp'. If 'netdev' is nonnull, adds it
457 * to the command as the port name attribute. Returns 0 if successful,
458 * otherwise a positive errno value. */
460 send_mgmt_command(struct dpif *dp, int command, const char *netdev)
462 struct buffer request, *reply;
465 buffer_init(&request, 0);
466 nl_msg_put_genlmsghdr(&request, dp->sock, 32, openflow_family,
467 NLM_F_REQUEST | NLM_F_ACK, command, 1);
468 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp->dp_idx);
470 nl_msg_put_string(&request, DP_GENL_A_PORTNAME, netdev);
472 retval = nl_sock_transact(dp->sock, &request, &reply);
473 buffer_uninit(&request);
474 buffer_delete(reply);