X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fpktbuf.c;h=b8698021d35ed1318c0ae9563a399329ffaf4e34;hb=d7436f763874179e086ff1f86bb2fe72596973a0;hp=b4198a8f6a2269074e2c53283c23f91b78ed6404;hpb=00908dc27a4d93bd1c5bda3bcdc84ec351e9a09a;p=sliver-openvswitch.git diff --git a/ofproto/pktbuf.c b/ofproto/pktbuf.c index b4198a8f6..b8698021d 100644 --- a/ofproto/pktbuf.c +++ b/ofproto/pktbuf.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,14 +19,20 @@ #include #include #include "coverage.h" +#include "ofp-util.h" #include "ofpbuf.h" #include "timeval.h" #include "util.h" #include "vconn.h" - -#define THIS_MODULE VLM_pktbuf #include "vlog.h" +VLOG_DEFINE_THIS_MODULE(pktbuf); + +COVERAGE_DEFINE(pktbuf_buffer_unknown); +COVERAGE_DEFINE(pktbuf_null_cookie); +COVERAGE_DEFINE(pktbuf_retrieved); +COVERAGE_DEFINE(pktbuf_reuse_error); + /* Buffers are identified by a 32-bit opaque ID. We divide the ID * into a buffer number (low bits) and a cookie (high bits). The buffer number * is an index into an array of buffers. The cookie distinguishes between @@ -51,6 +57,7 @@ struct packet { struct pktbuf { struct packet packets[PKTBUF_CNT]; unsigned int buffer_idx; + unsigned int null_idx; }; int @@ -62,7 +69,7 @@ pktbuf_capacity(void) struct pktbuf * pktbuf_create(void) { - return xcalloc(1, sizeof *pktbuf_create()); + return xzalloc(sizeof *pktbuf_create()); } void @@ -78,6 +85,22 @@ pktbuf_destroy(struct pktbuf *pb) } } +static unsigned int +make_id(unsigned int buffer_idx, unsigned int cookie) +{ + return buffer_idx | (cookie << PKTBUF_BITS); +} + +/* Attempts to allocate an OpenFlow packet buffer id within 'pb'. The packet + * buffer will store a copy of 'buffer' and the port number 'in_port', which + * should be the datapath port number on which 'buffer' was received. + * + * If successful, returns the packet buffer id (a number other than + * UINT32_MAX). pktbuf_retrieve() can later be used to retrieve the buffer and + * its input port number (buffers do expire after a time, so this is not + * guaranteed to be true forever). On failure, returns UINT32_MAX. + * + * The caller retains ownership of 'buffer'. */ uint32_t pktbuf_save(struct pktbuf *pb, struct ofpbuf *buffer, uint16_t in_port) { @@ -94,12 +117,54 @@ pktbuf_save(struct pktbuf *pb, struct ofpbuf *buffer, uint16_t in_port) if (++p->cookie >= COOKIE_MAX) { p->cookie = 0; } - p->buffer = ofpbuf_clone(buffer); + p->buffer = ofpbuf_new_with_headroom(buffer->size, + sizeof(struct ofp_packet_in)); + ofpbuf_put(p->buffer, buffer->data, buffer->size); p->timeout = time_msec() + OVERWRITE_MSECS; p->in_port = in_port; - return (p - pb->packets) | (p->cookie << PKTBUF_BITS); + return make_id(p - pb->packets, p->cookie); +} + +/* + * Allocates and returns a "null" packet buffer id. The returned packet buffer + * id is considered valid by pktbuf_retrieve(), but it is not associated with + * actual buffered data. + * + * This function is always successful. + * + * This is useful in one special case: with the current OpenFlow design, the + * "fail-open" code cannot always know whether a connection to a controller is + * actually valid until it receives a OFPT_PACKET_OUT or OFPT_FLOW_MOD request, + * but at that point the packet in question has already been forwarded (since + * we are still in "fail-open" mode). If the packet was buffered in the usual + * way, then the OFPT_PACKET_OUT or OFPT_FLOW_MOD would cause a duplicate + * packet in the network. Null packet buffer ids identify such a packet that + * has already been forwarded, so that Open vSwitch can quietly ignore the + * request to re-send it. (After that happens, the switch exits fail-open + * mode.) + * + * See the top-level comment in fail-open.c for an overview. + */ +uint32_t +pktbuf_get_null(void) +{ + return make_id(0, COOKIE_MAX); } +/* Attempts to retrieve a saved packet with the given 'id' from 'pb'. Returns + * 0 if successful, otherwise an OpenFlow error code constructed with + * ofp_mkerr(). + * + * On success, ordinarily stores the buffered packet in '*bufferp' and the + * datapath port number on which the packet was received in '*in_port'. The + * caller becomes responsible for freeing the buffer. However, if 'id' + * identifies a "null" packet buffer (created with pktbuf_get_null()), stores + * NULL in '*bufferp' and UINT16_max in '*in_port'. + * + * A returned packet will have at least sizeof(struct ofp_packet_in) bytes of + * headroom. + * + * On failure, stores NULL in in '*bufferp' and UINT16_MAX in '*in_port'. */ int pktbuf_retrieve(struct pktbuf *pb, uint32_t id, struct ofpbuf **bufferp, uint16_t *in_port) @@ -111,7 +176,7 @@ pktbuf_retrieve(struct pktbuf *pb, uint32_t id, struct ofpbuf **bufferp, if (!pb) { VLOG_WARN_RL(&rl, "attempt to send buffered packet via connection " "without buffers"); - return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_COOKIE); + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN); } p = &pb->packets[id & PKTBUF_MASK]; @@ -128,14 +193,19 @@ pktbuf_retrieve(struct pktbuf *pb, uint32_t id, struct ofpbuf **bufferp, VLOG_WARN_RL(&rl, "attempt to reuse buffer %08"PRIx32, id); error = ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY); } - } else { - COVERAGE_INC(pktbuf_bad_cookie); + } else if (id >> PKTBUF_BITS != COOKIE_MAX) { + COVERAGE_INC(pktbuf_buffer_unknown); VLOG_WARN_RL(&rl, "cookie mismatch: %08"PRIx32" != %08"PRIx32, id, (id & PKTBUF_MASK) | (p->cookie << PKTBUF_BITS)); - error = ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_COOKIE); + error = ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN); + } else { + COVERAGE_INC(pktbuf_null_cookie); + VLOG_INFO_RL(&rl, "Received null cookie %08"PRIx32" (this is normal " + "if the switch was recently in fail-open mode)", id); + error = 0; } *bufferp = NULL; - *in_port = -1; + *in_port = UINT16_MAX; return error; }