[openvswitch] / switch / controller.c

/* Copyright (C) 2008 Board of Trustees, Leland Stanford Jr. University.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "controller.h"
#include <errno.h>
#include <string.h>
#include "buffer.h"
#include "forward.h"
#include "poll-loop.h"
#include "ofp-print.h"
#include "util.h"
#include "vconn.h"

#define THIS_MODULE VLM_controller_connection
#include "vlog.h"

void
controller_init(struct controller_connection *cc,
                const char *name, bool reliable)
{
    cc->reliable = reliable;
    cc->name = name;
    cc->vconn = NULL;
    queue_init(&cc->txq);
    cc->backoff_deadline = 0;
    cc->backoff = 0;
}

static int
try_send(struct controller_connection *cc)
{
    int retval = 0;
    struct buffer *next = cc->txq.head->next;
    retval = vconn_send(cc->vconn, cc->txq.head);
    if (retval) {
        return retval;
    }
    queue_advance_head(&cc->txq, next);
    return 0;
}

void
controller_run(struct controller_connection *cc, struct datapath *dp)
{
    if (!cc->vconn) {
        if (time(0) >= cc->backoff_deadline) {
            int retval;

            retval = vconn_open(cc->name, &cc->vconn);
            if (!retval) {
                cc->backoff_deadline = time(0) + cc->backoff;
                cc->connected = false;
            } else {
                VLOG_WARN("%s: connection failed (%s)",
                          cc->name, strerror(retval)); 
                controller_disconnect(cc, 0);
            }
        }
    } else if (!cc->connected) {
        int error = vconn_connect(cc->vconn);
        if (!error) {
            VLOG_WARN("%s: connected", cc->name);
            if (vconn_is_passive(cc->vconn)) {
                fatal(0, "%s: passive vconn not supported in switch",
                      cc->name);
            }
            cc->connected = true;
        } else if (error != EAGAIN) {
            VLOG_WARN("%s: connection failed (%s)",
                      cc->name, strerror(error));
            controller_disconnect(cc, 0);
        }
    } else {
        int iterations;

        for (iterations = 0; iterations < 50; iterations++) {
            struct buffer *buffer;
            int error = vconn_recv(cc->vconn, &buffer);
            if (!error) {
                fwd_control_input(dp, buffer->data, buffer->size);
                buffer_delete(buffer);
            } else if (error == EAGAIN) {
                break;
            } else {
                controller_disconnect(cc, error);
                return;
            }
        }

        while (cc->txq.n > 0) {
            int error = try_send(cc);
            if (error == EAGAIN) {
                break;
            } else if (error) {
                controller_disconnect(cc, error);
                return;
            }
        } 
    }
}

void
controller_disconnect(struct controller_connection *cc, int error) 
{
    time_t now = time(0);
    
    if (cc->vconn) {
        if (!cc->reliable) {
            fatal(0, "%s: connection dropped", cc->name);
        }

        if (error > 0) {
            VLOG_WARN("%s: connection dropped (%s)",
                      cc->name, strerror(error)); 
        } else if (error == EOF) { 
            VLOG_WARN("%s: connection closed", cc->name); 
        } else {
            VLOG_WARN("%s: connection dropped", cc->name); 
        }
        vconn_close(cc->vconn);
        cc->vconn = NULL;
        queue_clear(&cc->txq);
    }

    if (now >= cc->backoff_deadline) {
        cc->backoff = 1;
    } else {
        cc->backoff = MIN(60, MAX(1, 2 * cc->backoff));
        VLOG_WARN("%s: waiting %d seconds before reconnect\n",
                  cc->name, cc->backoff);
    }
    cc->backoff_deadline = now + cc->backoff;
}

void
controller_wait(struct controller_connection *cc) 
{
    if (cc->vconn) {
        vconn_wait(cc->vconn, WAIT_RECV);
        if (cc->txq.n) {
            vconn_wait(cc->vconn, WAIT_SEND);
        }
    } else {
        poll_timer_wait((cc->backoff_deadline - time(0)) * 1000);
    }
}

void
controller_send(struct controller_connection *cc, struct buffer *b) 
{
    if (cc->vconn) {
        if (cc->txq.n < 128) {
            queue_push_tail(&cc->txq, b);
            if (cc->txq.n == 1) {
                try_send(cc);
            }
        } else {
            VLOG_WARN("%s: controller queue overflow", cc->name);
            buffer_delete(b);
        } 
    }
}