/usr/src/openvswitch-1.4.0/ofproto/pktbuf.c is in openvswitch-datapath-dkms 1.4.0-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 | /*
* Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include "pktbuf.h"
#include <inttypes.h>
#include <stdlib.h>
#include "coverage.h"
#include "ofp-util.h"
#include "ofpbuf.h"
#include "timeval.h"
#include "util.h"
#include "vconn.h"
#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
* different packets that have occupied a single buffer. Thus, the more
* buffers we have, the lower-quality the cookie... */
#define PKTBUF_BITS 8
#define PKTBUF_MASK (PKTBUF_CNT - 1)
#define PKTBUF_CNT (1u << PKTBUF_BITS)
#define COOKIE_BITS (32 - PKTBUF_BITS)
#define COOKIE_MAX ((1u << COOKIE_BITS) - 1)
#define OVERWRITE_MSECS 5000
struct packet {
struct ofpbuf *buffer;
uint32_t cookie;
long long int timeout;
uint16_t in_port;
};
struct pktbuf {
struct packet packets[PKTBUF_CNT];
unsigned int buffer_idx;
unsigned int null_idx;
};
int
pktbuf_capacity(void)
{
return PKTBUF_CNT;
}
struct pktbuf *
pktbuf_create(void)
{
return xzalloc(sizeof *pktbuf_create());
}
void
pktbuf_destroy(struct pktbuf *pb)
{
if (pb) {
size_t i;
for (i = 0; i < PKTBUF_CNT; i++) {
ofpbuf_delete(pb->packets[i].buffer);
}
free(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)
{
struct packet *p = &pb->packets[pb->buffer_idx];
pb->buffer_idx = (pb->buffer_idx + 1) & PKTBUF_MASK;
if (p->buffer) {
if (time_msec() < p->timeout) {
return UINT32_MAX;
}
ofpbuf_delete(p->buffer);
}
/* Don't use maximum cookie value since all-1-bits ID is special. */
if (++p->cookie >= COOKIE_MAX) {
p->cookie = 0;
}
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 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'.
*
* 'in_port' may be NULL if the input port is not of interest.
*
* 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)
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 20);
struct packet *p;
int error;
if (id == UINT32_MAX) {
error = 0;
goto error;
}
if (!pb) {
VLOG_WARN_RL(&rl, "attempt to send buffered packet via connection "
"without buffers");
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN);
}
p = &pb->packets[id & PKTBUF_MASK];
if (p->cookie == id >> PKTBUF_BITS) {
struct ofpbuf *buffer = p->buffer;
if (buffer) {
*bufferp = buffer;
if (in_port) {
*in_port = p->in_port;
}
p->buffer = NULL;
COVERAGE_INC(pktbuf_retrieved);
return 0;
} else {
COVERAGE_INC(pktbuf_reuse_error);
VLOG_WARN_RL(&rl, "attempt to reuse buffer %08"PRIx32, id);
error = ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY);
}
} 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_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;
}
error:
*bufferp = NULL;
if (in_port) {
*in_port = UINT16_MAX;
}
return error;
}
void
pktbuf_discard(struct pktbuf *pb, uint32_t id)
{
struct packet *p = &pb->packets[id & PKTBUF_MASK];
if (p->cookie == id >> PKTBUF_BITS) {
ofpbuf_delete(p->buffer);
p->buffer = NULL;
}
}
|