pintos-os.org Git - openvswitch/blob - switch/controller.c

   1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   2  * Junior University
   3  *
   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:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  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
  27  * SOFTWARE.
  28  *
  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.
  32  */
  33
  34 #include "controller.h"
  35 #include <errno.h>
  36 #include <string.h>
  37 #include "buffer.h"
  38 #include "poll-loop.h"
  39 #include "ofp-print.h"
  40 #include "util.h"
  41 #include "vconn.h"
  42
  43 #define THIS_MODULE VLM_controller_connection
  44 #include "vlog.h"
  45
  46 void
  47 controller_init(struct controller_connection *cc,
  48                 const char *name, bool reliable)
  49 {
  50     cc->reliable = reliable;
  51     cc->name = name;
  52     cc->vconn = NULL;
  53     queue_init(&cc->txq);
  54     cc->backoff_deadline = 0;
  55     cc->backoff = 0;
  56 }
  57
  58 static int
  59 try_send(struct controller_connection *cc)
  60 {
  61     int retval = 0;
  62     struct buffer *next = cc->txq.head->next;
  63     retval = vconn_send(cc->vconn, cc->txq.head);
  64     if (retval) {
  65         return retval;
  66     }
  67     queue_advance_head(&cc->txq, next);
  68     return 0;
  69 }
  70
  71 void
  72 controller_run(struct controller_connection *cc)
  73 {
  74     if (!cc->vconn) {
  75         if (time(0) >= cc->backoff_deadline) {
  76             int retval;
  77
  78             retval = vconn_open(cc->name, &cc->vconn);
  79             if (!retval) {
  80                 cc->backoff_deadline = time(0) + cc->backoff;
  81                 cc->connected = false;
  82             } else {
  83                 VLOG_WARN("%s: connection failed (%s)",
  84                           cc->name, strerror(retval));
  85                 controller_disconnect(cc, 0);
  86             }
  87         }
  88     } else if (!cc->connected) {
  89         int error = vconn_connect(cc->vconn);
  90         if (!error) {
  91             VLOG_WARN("%s: connected", cc->name);
  92             if (vconn_is_passive(cc->vconn)) {
  93                 fatal(0, "%s: passive vconn not supported in switch",
  94                       cc->name);
  95             }
  96             cc->connected = true;
  97         } else if (error != EAGAIN) {
  98             VLOG_WARN("%s: connection failed (%s)",
  99                       cc->name, strerror(error));
 100             controller_disconnect(cc, 0);
 101         }
 102     } else {
 103         while (cc->txq.n > 0) {
 104             int error = try_send(cc);
 105             if (error == EAGAIN) {
 106                 break;
 107             } else if (error) {
 108                 controller_disconnect(cc, error);
 109                 return;
 110             }
 111         }
 112     }
 113 }
 114
 115 void
 116 controller_run_wait(struct controller_connection *cc)
 117 {
 118     if (cc->vconn) {
 119         if (cc->txq.n) {
 120             vconn_wait(cc->vconn, WAIT_SEND);
 121         }
 122     } else {
 123         poll_timer_wait((cc->backoff_deadline - time(0)) * 1000);
 124     }
 125 }
 126
 127 void
 128 controller_disconnect(struct controller_connection *cc, int error)
 129 {
 130     time_t now = time(0);
 131
 132     if (cc->vconn) {
 133         if (!cc->reliable) {
 134             fatal(0, "%s: connection dropped", cc->name);
 135         }
 136
 137         if (error > 0) {
 138             VLOG_WARN("%s: connection dropped (%s)",
 139                       cc->name, strerror(error));
 140         } else if (error == EOF) {
 141             VLOG_WARN("%s: connection closed", cc->name);
 142         } else {
 143             VLOG_WARN("%s: connection dropped", cc->name);
 144         }
 145         vconn_close(cc->vconn);
 146         cc->vconn = NULL;
 147         queue_clear(&cc->txq);
 148     }
 149
 150     if (now >= cc->backoff_deadline) {
 151         cc->backoff = 1;
 152     } else {
 153         cc->backoff = MIN(60, MAX(1, 2 * cc->backoff));
 154         VLOG_WARN("%s: waiting %d seconds before reconnect\n",
 155                   cc->name, cc->backoff);
 156     }
 157     cc->backoff_deadline = now + cc->backoff;
 158 }
 159
 160 struct buffer *
 161 controller_recv(struct controller_connection *cc)
 162 {
 163     if (cc->vconn && cc->connected) {
 164         struct buffer *buffer;
 165         int error = vconn_recv(cc->vconn, &buffer);
 166         if (!error) {
 167             return buffer;
 168         } else if (error != EAGAIN) {
 169             controller_disconnect(cc, error);
 170         }
 171     }
 172     return NULL;
 173 }
 174
 175 void
 176 controller_recv_wait(struct controller_connection *cc)
 177 {
 178     if (cc->vconn) {
 179         vconn_wait(cc->vconn, WAIT_RECV);
 180     }
 181 }
 182
 183 void
 184 controller_send(struct controller_connection *cc, struct buffer *b)
 185 {
 186     if (cc->vconn) {
 187         if (cc->txq.n < 128) {
 188             queue_push_tail(&cc->txq, b);
 189             if (cc->txq.n == 1) {
 190                 try_send(cc);
 191             }
 192         } else {
 193             VLOG_WARN("%s: controller queue overflow", cc->name);
 194             buffer_delete(b);
 195         }
 196     }
 197 }