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.
40 #include <netinet/in.h>
46 #include "netlink-protocol.h"
47 #include "ofp-print.h"
48 #include "openflow-netlink.h"
55 #define THIS_MODULE VLM_dpif
57 /* Not really much point in logging many dpif errors. */
58 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 60);
60 /* The Generic Netlink family number used for OpenFlow. */
61 static int openflow_family;
63 static int lookup_openflow_multicast_group(int dp_idx, int *multicast_group);
64 static int send_mgmt_command(struct dpif *, int command,
67 /* Opens the local datapath numbered 'dp_idx', initializing 'dp'. If
68 * 'subscribe' is true, listens for asynchronous messages (packet-in, etc.)
69 * from the datapath; otherwise, 'dp' will receive only replies to explicitly
70 * initiated requests. */
72 dpif_open(int dp_idx, bool subscribe, struct dpif *dp)
75 int multicast_group = 0;
78 retval = nl_lookup_genl_family(DP_GENL_FAMILY_NAME, &openflow_family);
84 retval = lookup_openflow_multicast_group(dp_idx, &multicast_group);
90 /* Specify a large so_rcvbuf size because we occasionally need to be able
91 * to retrieve large collections of flow records. */
92 retval = nl_sock_create(NETLINK_GENERIC, multicast_group, 0,
93 4 * 1024u * 1024, &sock);
105 dpif_close(struct dpif *dp)
107 nl_sock_destroy(dp->sock);
110 static const struct nl_policy openflow_policy[] = {
111 [DP_GENL_A_DP_IDX] = { .type = NL_A_U32 },
112 [DP_GENL_A_OPENFLOW] = { .type = NL_A_UNSPEC,
113 .min_len = sizeof(struct ofp_header),
114 .max_len = OFP_MAXLEN },
117 /* Tries to receive an openflow message from the kernel on 'sock'. If
118 * successful, stores the received message into '*msgp' and returns 0. The
119 * caller is responsible for destroying the message with buffer_delete(). On
120 * failure, returns a positive errno value and stores a null pointer into
123 * Only Netlink messages with embedded OpenFlow messages are accepted. Other
124 * Netlink messages provoke errors.
126 * If 'wait' is true, dpif_recv_openflow waits for a message to be ready;
127 * otherwise, returns EAGAIN if the 'sock' receive buffer is empty. */
129 dpif_recv_openflow(struct dpif *dp, struct buffer **bufferp,
132 struct nlattr *attrs[ARRAY_SIZE(openflow_policy)];
133 struct buffer *buffer;
134 struct ofp_header *oh;
138 buffer = *bufferp = NULL;
140 buffer_delete(buffer);
141 retval = nl_sock_recv(dp->sock, &buffer, wait);
142 } while (retval == ENOBUFS
144 && (nl_msg_nlmsgerr(buffer, NULL)
145 || nl_msg_nlmsghdr(buffer)->nlmsg_type == NLMSG_DONE)));
147 if (retval != EAGAIN) {
148 VLOG_WARN_RL(&rl, "dpif_recv_openflow: %s", strerror(retval));
153 if (nl_msg_genlmsghdr(buffer) == NULL) {
154 VLOG_DBG_RL(&rl, "received packet too short for Generic Netlink");
157 if (nl_msg_nlmsghdr(buffer)->nlmsg_type != openflow_family) {
158 VLOG_DBG_RL(&rl, "received type (%"PRIu16") != openflow family (%d)",
159 nl_msg_nlmsghdr(buffer)->nlmsg_type, openflow_family);
163 if (!nl_policy_parse(buffer, openflow_policy, attrs,
164 ARRAY_SIZE(openflow_policy))) {
167 if (nl_attr_get_u32(attrs[DP_GENL_A_DP_IDX]) != dp->dp_idx) {
168 VLOG_WARN_RL(&rl, "received dp_idx (%"PRIu32") differs from expected "
169 "(%d)", nl_attr_get_u32(attrs[DP_GENL_A_DP_IDX]),
174 oh = buffer->data = (void *) nl_attr_get(attrs[DP_GENL_A_OPENFLOW]);
175 buffer->size = nl_attr_get_size(attrs[DP_GENL_A_OPENFLOW]);
176 ofp_len = ntohs(oh->length);
177 if (ofp_len != buffer->size) {
179 "ofp_header.length %"PRIu16" != attribute length %zu\n",
180 ofp_len, buffer->size);
181 buffer->size = MIN(ofp_len, buffer->size);
187 buffer_delete(buffer);
191 /* Encapsulates 'msg', which must contain an OpenFlow message, in a Netlink
192 * message, and sends it to the OpenFlow kernel module via 'sock'.
194 * Returns 0 if successful, otherwise a positive errno value. If
195 * 'wait' is true, then the send will wait until buffer space is ready;
196 * otherwise, returns EAGAIN if the 'sock' send buffer is full.
198 * If the send is successful, then the kernel module will receive it, but there
199 * is no guarantee that any reply will not be dropped (see nl_sock_transact()
203 dpif_send_openflow(struct dpif *dp, struct buffer *buffer, bool wait)
205 struct ofp_header *oh;
206 unsigned int dump_flag;
209 uint32_t fixed_buffer[64 / 4];
215 /* The reply to OFPT_STATS_REQUEST may be multiple segments long, so we
216 * need to specify NLM_F_DUMP in the request. */
217 oh = buffer_at_assert(buffer, 0, sizeof *oh);
218 dump_flag = oh->type == OFPT_STATS_REQUEST ? NLM_F_DUMP : 0;
220 buffer_use(&hdr, fixed_buffer, sizeof fixed_buffer);
221 nl_msg_put_genlmsghdr(&hdr, dp->sock, 32, openflow_family,
222 NLM_F_REQUEST | dump_flag, DP_GENL_C_OPENFLOW, 1);
223 nl_msg_put_u32(&hdr, DP_GENL_A_DP_IDX, dp->dp_idx);
224 nla = buffer_put_uninit(&hdr, sizeof *nla);
225 nla->nla_len = sizeof *nla + buffer->size;
226 nla->nla_type = DP_GENL_A_OPENFLOW;
227 pad_bytes = NLA_ALIGN(nla->nla_len) - nla->nla_len;
228 nl_msg_nlmsghdr(&hdr)->nlmsg_len = hdr.size + buffer->size + pad_bytes;
230 iov[0].iov_base = hdr.data;
231 iov[0].iov_len = hdr.size;
232 iov[1].iov_base = buffer->data;
233 iov[1].iov_len = buffer->size;
235 static char zeros[NLA_ALIGNTO];
237 iov[2].iov_base = zeros;
238 iov[2].iov_len = pad_bytes;
240 retval = nl_sock_sendv(dp->sock, iov, n_iov, false);
241 if (retval && retval != EAGAIN) {
242 VLOG_WARN_RL(&rl, "dpif_send_openflow: %s", strerror(retval));
247 /* Creates the datapath represented by 'dp'. Returns 0 if successful,
248 * otherwise a positive errno value. */
250 dpif_add_dp(struct dpif *dp)
252 return send_mgmt_command(dp, DP_GENL_C_ADD_DP, NULL);
255 /* Destroys the datapath represented by 'dp'. Returns 0 if successful,
256 * otherwise a positive errno value. */
258 dpif_del_dp(struct dpif *dp)
260 return send_mgmt_command(dp, DP_GENL_C_DEL_DP, NULL);
263 /* Adds the Ethernet device named 'netdev' to this datapath. Returns 0 if
264 * successful, otherwise a positive errno value. */
266 dpif_add_port(struct dpif *dp, const char *netdev)
268 return send_mgmt_command(dp, DP_GENL_C_ADD_PORT, netdev);
271 /* Removes the Ethernet device named 'netdev' from this datapath. Returns 0
272 * if successful, otherwise a positive errno value. */
274 dpif_del_port(struct dpif *dp, const char *netdev)
276 return send_mgmt_command(dp, DP_GENL_C_DEL_PORT, netdev);
279 static const struct nl_policy openflow_multicast_policy[] = {
280 [DP_GENL_A_DP_IDX] = { .type = NL_A_U32 },
281 [DP_GENL_A_MC_GROUP] = { .type = NL_A_U32 },
284 /* Looks up the Netlink multicast group used by datapath 'dp_idx'. If
285 * successful, stores the multicast group in '*multicast_group' and returns 0.
286 * Otherwise, returns a positve errno value. */
288 lookup_openflow_multicast_group(int dp_idx, int *multicast_group)
290 struct nl_sock *sock;
291 struct buffer request, *reply;
292 struct nlattr *attrs[ARRAY_SIZE(openflow_multicast_policy)];
295 retval = nl_sock_create(NETLINK_GENERIC, 0, 0, 0, &sock);
299 buffer_init(&request, 0);
300 nl_msg_put_genlmsghdr(&request, sock, 0, openflow_family, NLM_F_REQUEST,
301 DP_GENL_C_QUERY_DP, 1);
302 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp_idx);
303 retval = nl_sock_transact(sock, &request, &reply);
304 buffer_uninit(&request);
306 nl_sock_destroy(sock);
309 if (!nl_policy_parse(reply, openflow_multicast_policy, attrs,
310 ARRAY_SIZE(openflow_multicast_policy))) {
311 nl_sock_destroy(sock);
312 buffer_delete(reply);
315 *multicast_group = nl_attr_get_u32(attrs[DP_GENL_A_MC_GROUP]);
316 nl_sock_destroy(sock);
317 buffer_delete(reply);
322 /* Sends the given 'command' to datapath 'dp'. If 'netdev' is nonnull, adds it
323 * to the command as the port name attribute. Returns 0 if successful,
324 * otherwise a positive errno value. */
326 send_mgmt_command(struct dpif *dp, int command, const char *netdev)
328 struct buffer request, *reply;
331 buffer_init(&request, 0);
332 nl_msg_put_genlmsghdr(&request, dp->sock, 32, openflow_family,
333 NLM_F_REQUEST | NLM_F_ACK, command, 1);
334 nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, dp->dp_idx);
336 nl_msg_put_string(&request, DP_GENL_A_PORTNAME, netdev);
338 retval = nl_sock_transact(dp->sock, &request, &reply);
339 buffer_uninit(&request);
340 buffer_delete(reply);