X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fvconn.c;h=9271f4f155e93699ade8f5be7520ef495f4ffd22;hb=b19e8793390f788a4e394d049ea64ce0161ad923;hp=b558f8069fd085f3c58eb3e6aca926d2b9b15984;hpb=b0bfeb3e693332a98878032b5d05c85210e5feb9;p=sliver-openvswitch.git diff --git a/lib/vconn.c b/lib/vconn.c index b558f8069..9271f4f15 100644 --- a/lib/vconn.c +++ b/lib/vconn.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,6 +27,8 @@ #include "dynamic-string.h" #include "fatal-signal.h" #include "flow.h" +#include "ofp-errors.h" +#include "ofp-msgs.h" #include "ofp-print.h" #include "ofp-util.h" #include "ofpbuf.h" @@ -36,9 +38,14 @@ #include "poll-loop.h" #include "random.h" #include "util.h" - -#define THIS_MODULE VLM_vconn #include "vlog.h" +#include "socket-util.h" + +VLOG_DEFINE_THIS_MODULE(vconn); + +COVERAGE_DEFINE(vconn_open); +COVERAGE_DEFINE(vconn_received); +COVERAGE_DEFINE(vconn_sent); /* State of an active vconn.*/ enum vconn_state { @@ -127,14 +134,14 @@ vconn_usage(bool active, bool passive, bool bootstrap OVS_UNUSED) /* Really this should be implemented via callbacks into the vconn * providers, but that seems too heavy-weight to bother with at the * moment. */ - + printf("\n"); if (active) { printf("Active OpenFlow connection methods:\n"); - printf(" tcp:IP[:PORT] " + printf(" tcp:IP[:PORT] " "PORT (default: %d) at remote IP\n", OFP_TCP_PORT); #ifdef HAVE_OPENSSL - printf(" ssl:IP[:PORT] " + printf(" ssl:IP[:PORT] " "SSL PORT (default: %d) at remote IP\n", OFP_SSL_PORT); #endif printf(" unix:FILE Unix domain socket named FILE\n"); @@ -208,13 +215,14 @@ vconn_verify_name(const char *name) * * The vconn will automatically negotiate an OpenFlow protocol version * acceptable to both peers on the connection. The version negotiated will be - * no lower than 'min_version' and no higher than OFP_VERSION. + * no lower than 'min_version' and no higher than OFP10_VERSION. * * Returns 0 if successful, otherwise a positive errno value. If successful, * stores a pointer to the new connection in '*vconnp', otherwise a null * pointer. */ int -vconn_open(const char *name, int min_version, struct vconn **vconnp) +vconn_open(const char *name, int min_version, struct vconn **vconnp, + uint8_t dscp) { struct vconn_class *class; struct vconn *vconn; @@ -232,7 +240,7 @@ vconn_open(const char *name, int min_version, struct vconn **vconnp) /* Call class's "open" function. */ suffix_copy = xstrdup(strchr(name, ':') + 1); - error = class->open(name, suffix_copy, &vconn); + error = class->open(name, suffix_copy, &vconn, dscp); free(suffix_copy); if (error) { goto error; @@ -254,6 +262,12 @@ error: void vconn_run(struct vconn *vconn) { + if (vconn->state == VCS_CONNECTING || + vconn->state == VCS_SEND_HELLO || + vconn->state == VCS_RECV_HELLO) { + vconn_connect(vconn); + } + if (vconn->class->run) { (vconn->class->run)(vconn); } @@ -264,28 +278,29 @@ vconn_run(struct vconn *vconn) void vconn_run_wait(struct vconn *vconn) { + if (vconn->state == VCS_CONNECTING || + vconn->state == VCS_SEND_HELLO || + vconn->state == VCS_RECV_HELLO) { + vconn_connect_wait(vconn); + } + if (vconn->class->run_wait) { (vconn->class->run_wait)(vconn); } } int -vconn_open_block(const char *name, int min_version, struct vconn **vconnp) +vconn_open_block(const char *name, enum ofp_version min_version, + struct vconn **vconnp) { struct vconn *vconn; int error; fatal_signal_run(); - error = vconn_open(name, min_version, &vconn); + error = vconn_open(name, min_version, &vconn, DSCP_DEFAULT); if (!error) { - while ((error == vconn_connect(vconn)) == EAGAIN) { - vconn_run(vconn); - vconn_run_wait(vconn); - vconn_connect_wait(vconn); - poll_block(); - } - assert(error != EINPROGRESS); + error = vconn_connect_block(vconn); } if (error) { @@ -317,39 +332,50 @@ vconn_get_name(const struct vconn *vconn) /* Returns the IP address of the peer, or 0 if the peer is not connected over * an IP-based protocol or if its IP address is not yet known. */ -uint32_t -vconn_get_remote_ip(const struct vconn *vconn) +ovs_be32 +vconn_get_remote_ip(const struct vconn *vconn) { return vconn->remote_ip; } -/* Returns the transport port of the peer, or 0 if the connection does not +/* Returns the transport port of the peer, or 0 if the connection does not * contain a port or if the port is not yet known. */ -uint16_t -vconn_get_remote_port(const struct vconn *vconn) +ovs_be16 +vconn_get_remote_port(const struct vconn *vconn) { return vconn->remote_port; } -/* Returns the IP address used to connect to the peer, or 0 if the - * connection is not an IP-based protocol or if its IP address is not +/* Returns the IP address used to connect to the peer, or 0 if the + * connection is not an IP-based protocol or if its IP address is not * yet known. */ -uint32_t -vconn_get_local_ip(const struct vconn *vconn) +ovs_be32 +vconn_get_local_ip(const struct vconn *vconn) { return vconn->local_ip; } -/* Returns the transport port used to connect to the peer, or 0 if the +/* Returns the transport port used to connect to the peer, or 0 if the * connection does not contain a port or if the port is not yet known. */ -uint16_t -vconn_get_local_port(const struct vconn *vconn) +ovs_be16 +vconn_get_local_port(const struct vconn *vconn) { return vconn->local_port; } +/* Returns the OpenFlow version negotiated with the peer, or -1 if version + * negotiation is not yet complete. + * + * A vconn that has successfully connected (that is, vconn_connect() or + * vconn_send() or vconn_recv() has returned 0) always negotiated a version. */ +int +vconn_get_version(const struct vconn *vconn) +{ + return vconn->version ? vconn->version : -1; +} + static void -vcs_connecting(struct vconn *vconn) +vcs_connecting(struct vconn *vconn) { int retval = (vconn->class->connect)(vconn); assert(retval != EINPROGRESS); @@ -367,7 +393,7 @@ vcs_send_hello(struct vconn *vconn) struct ofpbuf *b; int retval; - make_openflow(sizeof(struct ofp_header), OFPT_HELLO, &b); + b = ofpraw_alloc(OFPRAW_OFPT_HELLO, OFP10_VERSION, 0); retval = do_send(vconn, b); if (!retval) { vconn->state = VCS_RECV_HELLO; @@ -388,9 +414,12 @@ vcs_recv_hello(struct vconn *vconn) retval = do_recv(vconn, &b); if (!retval) { - struct ofp_header *oh = b->data; + const struct ofp_header *oh = b->data; + enum ofptype type; + enum ofperr error; - if (oh->type == OFPT_HELLO) { + error = ofptype_decode(&type, b->data); + if (!error && type == OFPTYPE_HELLO) { if (b->size > sizeof *oh) { struct ds msg = DS_EMPTY_INITIALIZER; ds_put_format(&msg, "%s: extra-long hello:\n", vconn->name); @@ -399,13 +428,13 @@ vcs_recv_hello(struct vconn *vconn) ds_destroy(&msg); } - vconn->version = MIN(OFP_VERSION, oh->version); + vconn->version = MIN(OFP10_VERSION, oh->version); if (vconn->version < vconn->min_version) { VLOG_WARN_RL(&bad_ofmsg_rl, "%s: version negotiation failed: we support " "versions 0x%02x to 0x%02x inclusive but peer " "supports no later than version 0x%02"PRIx8, - vconn->name, vconn->min_version, OFP_VERSION, + vconn->name, vconn->min_version, OFP10_VERSION, oh->version); vconn->state = VCS_SEND_ERROR; } else { @@ -413,7 +442,7 @@ vcs_recv_hello(struct vconn *vconn) "(we support versions 0x%02x to 0x%02x inclusive, " "peer no later than version 0x%02"PRIx8")", vconn->name, vconn->version, vconn->min_version, - OFP_VERSION, oh->version); + OFP10_VERSION, oh->version); vconn->state = VCS_CONNECTED; } ofpbuf_delete(b); @@ -438,19 +467,14 @@ vcs_recv_hello(struct vconn *vconn) static void vcs_send_error(struct vconn *vconn) { - struct ofp_error_msg *error; struct ofpbuf *b; char s[128]; int retval; snprintf(s, sizeof s, "We support versions 0x%02x to 0x%02x inclusive but " "you support no later than version 0x%02"PRIx8".", - vconn->min_version, OFP_VERSION, vconn->version); - error = make_openflow(sizeof *error, OFPT_ERROR, &b); - error->type = htons(OFPET_HELLO_FAILED); - error->code = htons(OFPHFC_INCOMPATIBLE); - ofpbuf_put(b, s, strlen(s)); - update_openflow_length(b); + vconn->min_version, OFP12_VERSION, vconn->version); + b = ofperr_encode_hello(OFPERR_OFPHFC_INCOMPATIBLE, vconn->version, s); retval = do_send(vconn, b); if (retval) { ofpbuf_delete(b); @@ -461,16 +485,16 @@ vcs_send_error(struct vconn *vconn) } } -/* Tries to complete the connection on 'vconn', which must be an active - * vconn. If 'vconn''s connection is complete, returns 0 if the connection - * was successful or a positive errno value if it failed. If the - * connection is still in progress, returns EAGAIN. */ +/* Tries to complete the connection on 'vconn'. If 'vconn''s connection is + * complete, returns 0 if the connection was successful or a positive errno + * value if it failed. If the connection is still in progress, returns + * EAGAIN. */ int vconn_connect(struct vconn *vconn) { enum vconn_state last_state; - assert(vconn->min_version >= 0); + assert(vconn->min_version > 0); do { last_state = vconn->state; switch (vconn->state) { @@ -504,21 +528,44 @@ vconn_connect(struct vconn *vconn) return EAGAIN; } -/* Tries to receive an OpenFlow message from 'vconn', which must be an active - * vconn. If successful, stores the received message into '*msgp' and returns - * 0. The caller is responsible for destroying the message with - * ofpbuf_delete(). On failure, returns a positive errno value and stores a - * null pointer into '*msgp'. On normal connection close, returns EOF. +/* Tries to receive an OpenFlow message from 'vconn'. If successful, stores + * the received message into '*msgp' and returns 0. The caller is responsible + * for destroying the message with ofpbuf_delete(). On failure, returns a + * positive errno value and stores a null pointer into '*msgp'. On normal + * connection close, returns EOF. * * vconn_recv will not block waiting for a packet to arrive. If no packets * have been received, it returns EAGAIN immediately. */ int vconn_recv(struct vconn *vconn, struct ofpbuf **msgp) { - int retval = vconn_connect(vconn); + struct ofpbuf *msg; + int retval; + + retval = vconn_connect(vconn); + if (!retval) { + retval = do_recv(vconn, &msg); + } if (!retval) { - retval = do_recv(vconn, msgp); + const struct ofp_header *oh = msg->data; + if (oh->version != vconn->version) { + enum ofptype type; + + if (ofptype_decode(&type, msg->data) + || (type != OFPTYPE_HELLO && + type != OFPTYPE_ERROR && + type != OFPTYPE_ECHO_REQUEST && + type != OFPTYPE_ECHO_REPLY)) { + VLOG_ERR_RL(&bad_ofmsg_rl, "%s: received OpenFlow version " + "0x%02"PRIx8" != expected %02x", + vconn->name, oh->version, vconn->version); + ofpbuf_delete(msg); + retval = EPROTO; + } + } } + + *msgp = retval ? NULL : msg; return retval; } @@ -527,49 +574,20 @@ do_recv(struct vconn *vconn, struct ofpbuf **msgp) { int retval = (vconn->class->recv)(vconn, msgp); if (!retval) { - struct ofp_header *oh; - COVERAGE_INC(vconn_received); if (VLOG_IS_DBG_ENABLED()) { char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1); VLOG_DBG_RL(&ofmsg_rl, "%s: received: %s", vconn->name, s); free(s); } - - oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh); - if (oh->version != vconn->version - && oh->type != OFPT_HELLO - && oh->type != OFPT_ERROR - && oh->type != OFPT_ECHO_REQUEST - && oh->type != OFPT_ECHO_REPLY - && oh->type != OFPT_VENDOR) - { - if (vconn->version < 0) { - VLOG_ERR_RL(&bad_ofmsg_rl, - "%s: received OpenFlow message type %"PRIu8" " - "before version negotiation complete", - vconn->name, oh->type); - } else { - VLOG_ERR_RL(&bad_ofmsg_rl, - "%s: received OpenFlow version 0x%02"PRIx8" " - "!= expected %02x", - vconn->name, oh->version, vconn->version); - } - ofpbuf_delete(*msgp); - retval = EPROTO; - } - } - if (retval) { - *msgp = NULL; } return retval; } -/* Tries to queue 'msg' for transmission on 'vconn', which must be an active - * vconn. If successful, returns 0, in which case ownership of 'msg' is - * transferred to the vconn. Success does not guarantee that 'msg' has been or - * ever will be delivered to the peer, only that it has been queued for - * transmission. +/* Tries to queue 'msg' for transmission on 'vconn'. If successful, returns 0, + * in which case ownership of 'msg' is transferred to the vconn. Success does + * not guarantee that 'msg' has been or ever will be delivered to the peer, + * only that it has been queued for transmission. * * Returns a positive errno value on failure, in which case the caller * retains ownership of 'msg'. @@ -592,7 +610,8 @@ do_send(struct vconn *vconn, struct ofpbuf *msg) int retval; assert(msg->size >= sizeof(struct ofp_header)); - assert(((struct ofp_header *) msg->data)->length == htons(msg->size)); + + ofpmsg_update_length(msg); if (!VLOG_IS_DBG_ENABLED()) { COVERAGE_INC(vconn_sent); retval = (vconn->class->send)(vconn, msg); @@ -608,6 +627,24 @@ do_send(struct vconn *vconn, struct ofpbuf *msg) return retval; } +/* Same as vconn_connect(), except that it waits until the connection on + * 'vconn' completes or fails. Thus, it will never return EAGAIN. */ +int +vconn_connect_block(struct vconn *vconn) +{ + int error; + + while ((error = vconn_connect(vconn)) == EAGAIN) { + vconn_run(vconn); + vconn_run_wait(vconn); + vconn_connect_wait(vconn); + poll_block(); + } + assert(error != EINPROGRESS); + + return error; +} + /* Same as vconn_send, except that it waits until 'msg' can be transmitted. */ int vconn_send_block(struct vconn *vconn, struct ofpbuf *msg) @@ -649,10 +686,10 @@ vconn_recv_block(struct vconn *vconn, struct ofpbuf **msgp) * * 'request' is always destroyed, regardless of the return value. */ int -vconn_recv_xid(struct vconn *vconn, uint32_t xid, struct ofpbuf **replyp) +vconn_recv_xid(struct vconn *vconn, ovs_be32 xid, struct ofpbuf **replyp) { for (;;) { - uint32_t recv_xid; + ovs_be32 recv_xid; struct ofpbuf *reply; int error; @@ -668,7 +705,8 @@ vconn_recv_xid(struct vconn *vconn, uint32_t xid, struct ofpbuf **replyp) } VLOG_DBG_RL(&bad_ofmsg_rl, "%s: received reply with xid %08"PRIx32 - " != expected %08"PRIx32, vconn->name, recv_xid, xid); + " != expected %08"PRIx32, + vconn->name, ntohl(recv_xid), ntohl(xid)); ofpbuf_delete(reply); } } @@ -678,12 +716,16 @@ vconn_recv_xid(struct vconn *vconn, uint32_t xid, struct ofpbuf **replyp) * is stored in '*replyp' for the caller to examine and free. Otherwise * returns a positive errno value, or EOF, and sets '*replyp' to null. * + * 'request' should be an OpenFlow request that requires a reply. Otherwise, + * if there is no reply, this function can end up blocking forever (or until + * the peer drops the connection). + * * 'request' is always destroyed, regardless of the return value. */ int vconn_transact(struct vconn *vconn, struct ofpbuf *request, struct ofpbuf **replyp) { - uint32_t send_xid = ((struct ofp_header *) request->data)->xid; + ovs_be32 send_xid = ((struct ofp_header *) request->data)->xid; int error; *replyp = NULL; @@ -694,6 +736,104 @@ vconn_transact(struct vconn *vconn, struct ofpbuf *request, return error ? error : vconn_recv_xid(vconn, send_xid, replyp); } +/* Sends 'request' followed by a barrier request to 'vconn', then blocks until + * it receives a reply to the barrier. If successful, stores the reply to + * 'request' in '*replyp', if one was received, and otherwise NULL, then + * returns 0. Otherwise returns a positive errno value, or EOF, and sets + * '*replyp' to null. + * + * This function is useful for sending an OpenFlow request that doesn't + * ordinarily include a reply but might report an error in special + * circumstances. + * + * 'request' is always destroyed, regardless of the return value. */ +int +vconn_transact_noreply(struct vconn *vconn, struct ofpbuf *request, + struct ofpbuf **replyp) +{ + ovs_be32 request_xid; + ovs_be32 barrier_xid; + struct ofpbuf *barrier; + int error; + + *replyp = NULL; + + /* Send request. */ + request_xid = ((struct ofp_header *) request->data)->xid; + error = vconn_send_block(vconn, request); + if (error) { + ofpbuf_delete(request); + return error; + } + + /* Send barrier. */ + barrier = ofputil_encode_barrier_request(vconn_get_version(vconn)); + barrier_xid = ((struct ofp_header *) barrier->data)->xid; + error = vconn_send_block(vconn, barrier); + if (error) { + ofpbuf_delete(barrier); + return error; + } + + for (;;) { + struct ofpbuf *msg; + ovs_be32 msg_xid; + int error; + + error = vconn_recv_block(vconn, &msg); + if (error) { + ofpbuf_delete(*replyp); + *replyp = NULL; + return error; + } + + msg_xid = ((struct ofp_header *) msg->data)->xid; + if (msg_xid == request_xid) { + if (*replyp) { + VLOG_WARN_RL(&bad_ofmsg_rl, "%s: duplicate replies with " + "xid %08"PRIx32, vconn->name, ntohl(msg_xid)); + ofpbuf_delete(*replyp); + } + *replyp = msg; + } else { + ofpbuf_delete(msg); + if (msg_xid == barrier_xid) { + return 0; + } else { + VLOG_DBG_RL(&bad_ofmsg_rl, "%s: reply with xid %08"PRIx32 + " != expected %08"PRIx32" or %08"PRIx32, + vconn->name, ntohl(msg_xid), + ntohl(request_xid), ntohl(barrier_xid)); + } + } + } +} + +/* vconn_transact_noreply() for a list of "struct ofpbuf"s, sent one by one. + * All of the requests on 'requests' are always destroyed, regardless of the + * return value. */ +int +vconn_transact_multiple_noreply(struct vconn *vconn, struct list *requests, + struct ofpbuf **replyp) +{ + struct ofpbuf *request, *next; + + LIST_FOR_EACH_SAFE (request, next, list_node, requests) { + int error; + + list_remove(&request->list_node); + + error = vconn_transact_noreply(vconn, request, replyp); + if (error || *replyp) { + ofpbuf_list_delete(requests); + return error; + } + } + + *replyp = NULL; + return 0; +} + void vconn_wait(struct vconn *vconn, enum vconn_wait_type wait) { @@ -785,7 +925,7 @@ pvconn_verify_name(const char *name) * stores a pointer to the new connection in '*pvconnp', otherwise a null * pointer. */ int -pvconn_open(const char *name, struct pvconn **pvconnp) +pvconn_open(const char *name, struct pvconn **pvconnp, uint8_t dscp) { struct pvconn_class *class; struct pvconn *pvconn; @@ -802,7 +942,7 @@ pvconn_open(const char *name, struct pvconn **pvconnp) /* Call class's "open" function. */ suffix_copy = xstrdup(strchr(name, ':') + 1); - error = class->listen(name, suffix_copy, &pvconn); + error = class->listen(name, suffix_copy, &pvconn, dscp); free(suffix_copy); if (error) { goto error; @@ -842,7 +982,7 @@ pvconn_close(struct pvconn *pvconn) * * The new vconn will automatically negotiate an OpenFlow protocol version * acceptable to both peers on the connection. The version negotiated will be - * no lower than 'min_version' and no higher than OFP_VERSION. + * no lower than 'min_version' and no higher than OFP10_VERSION. * * pvconn_accept() will not block waiting for a connection. If no connection * is ready to be accepted, it returns EAGAIN immediately. */ @@ -892,8 +1032,8 @@ vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status, : !connect_status ? VCS_SEND_HELLO : VCS_DISCONNECTED); vconn->error = connect_status; - vconn->version = -1; - vconn->min_version = -1; + vconn->version = 0; + vconn->min_version = 0; vconn->remote_ip = 0; vconn->remote_port = 0; vconn->local_ip = 0; @@ -903,25 +1043,25 @@ vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status, } void -vconn_set_remote_ip(struct vconn *vconn, uint32_t ip) +vconn_set_remote_ip(struct vconn *vconn, ovs_be32 ip) { vconn->remote_ip = ip; } void -vconn_set_remote_port(struct vconn *vconn, uint16_t port) +vconn_set_remote_port(struct vconn *vconn, ovs_be16 port) { vconn->remote_port = port; } -void -vconn_set_local_ip(struct vconn *vconn, uint32_t ip) +void +vconn_set_local_ip(struct vconn *vconn, ovs_be32 ip) { vconn->local_ip = ip; } -void -vconn_set_local_port(struct vconn *vconn, uint16_t port) +void +vconn_set_local_port(struct vconn *vconn, ovs_be16 port) { vconn->local_port = port; }