ofproto/status.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "status.h"
  19 #include <arpa/inet.h>
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <inttypes.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include "dynamic-string.h"
  26 #include "list.h"
  27 #include "ofp-util.h"
  28 #include "ofpbuf.h"
  29 #include "ofproto.h"
  30 #include "openflow/nicira-ext.h"
  31 #include "packets.h"
  32 #include "rconn.h"
  33 #include "svec.h"
  34 #include "timeval.h"
  35 #include "vconn.h"
  36 #include "vlog.h"
  37
  38 VLOG_DEFINE_THIS_MODULE(status);
  39
  40 struct status_category {
  41     struct list node;
  42     char *name;
  43     void (*cb)(struct status_reply *, void *aux);
  44     void *aux;
  45 };
  46
  47 struct switch_status {
  48     time_t booted;
  49     struct status_category *config_cat;
  50     struct status_category *switch_cat;
  51     struct list categories;
  52 };
  53
  54 struct status_reply {
  55     struct status_category *category;
  56     struct ds request;
  57     struct ds output;
  58 };
  59
  60 int
  61 switch_status_handle_request(struct switch_status *ss, struct rconn *rconn,
  62                              struct nicira_header *request)
  63 {
  64     struct status_category *c;
  65     struct nicira_header *reply;
  66     struct status_reply sr;
  67     struct ofpbuf *b;
  68     int retval;
  69
  70     sr.request.string = (void *) (request + 1);
  71     sr.request.length = ntohs(request->header.length) - sizeof *request;
  72     ds_init(&sr.output);
  73     LIST_FOR_EACH (c, node, &ss->categories) {
  74         if (!memcmp(c->name, sr.request.string,
  75                     MIN(strlen(c->name), sr.request.length))) {
  76             sr.category = c;
  77             c->cb(&sr, c->aux);
  78         }
  79     }
  80     reply = make_nxmsg_xid(sizeof *reply + sr.output.length,
  81                            NXT_STATUS_REPLY, request->header.xid, &b);
  82     memcpy(reply + 1, sr.output.string, sr.output.length);
  83     retval = rconn_send(rconn, b, NULL);
  84     if (retval && retval != EAGAIN) {
  85         VLOG_WARN("send failed (%s)", strerror(retval));
  86     }
  87     ds_destroy(&sr.output);
  88     return 0;
  89 }
  90
  91 void
  92 rconn_status_cb(struct status_reply *sr, void *rconn_)
  93 {
  94     struct rconn *rconn = rconn_;
  95     time_t now = time_now();
  96     uint32_t remote_ip = rconn_get_remote_ip(rconn);
  97     uint32_t local_ip = rconn_get_local_ip(rconn);
  98
  99     status_reply_put(sr, "name=%s", rconn_get_target(rconn));
 100     if (remote_ip) {
 101         status_reply_put(sr, "remote-ip="IP_FMT, IP_ARGS(&remote_ip));
 102         status_reply_put(sr, "remote-port=%d",
 103                          ntohs(rconn_get_remote_port(rconn)));
 104         status_reply_put(sr, "local-ip="IP_FMT, IP_ARGS(&local_ip));
 105         status_reply_put(sr, "local-port=%d",
 106                          ntohs(rconn_get_local_port(rconn)));
 107     }
 108     status_reply_put(sr, "state=%s", rconn_get_state(rconn));
 109     status_reply_put(sr, "backoff=%d", rconn_get_backoff(rconn));
 110     status_reply_put(sr, "probe-interval=%d", rconn_get_probe_interval(rconn));
 111     status_reply_put(sr, "is-connected=%s",
 112                      rconn_is_connected(rconn) ? "true" : "false");
 113     status_reply_put(sr, "sent-msgs=%u", rconn_packets_sent(rconn));
 114     status_reply_put(sr, "received-msgs=%u", rconn_packets_received(rconn));
 115     status_reply_put(sr, "attempted-connections=%u",
 116                      rconn_get_attempted_connections(rconn));
 117     status_reply_put(sr, "successful-connections=%u",
 118                      rconn_get_successful_connections(rconn));
 119     status_reply_put(sr, "last-connection=%ld",
 120                      (long int) (now - rconn_get_last_connection(rconn)));
 121     status_reply_put(sr, "last-received=%ld",
 122                      (long int) (now - rconn_get_last_received(rconn)));
 123     status_reply_put(sr, "time-connected=%lu",
 124                      rconn_get_total_time_connected(rconn));
 125     status_reply_put(sr, "state-elapsed=%u", rconn_get_state_elapsed(rconn));
 126 }
 127
 128 static void
 129 config_status_cb(struct status_reply *sr, void *ofproto_)
 130 {
 131     const struct ofproto *ofproto = ofproto_;
 132     uint64_t datapath_id;
 133
 134     datapath_id = ofproto_get_datapath_id(ofproto);
 135     if (datapath_id) {
 136         status_reply_put(sr, "datapath-id=%016"PRIx64, datapath_id);
 137     }
 138 }
 139
 140 static void
 141 switch_status_cb(struct status_reply *sr, void *ss_)
 142 {
 143     struct switch_status *ss = ss_;
 144     time_t now = time_now();
 145
 146     status_reply_put(sr, "now=%ld", (long int) now);
 147     status_reply_put(sr, "uptime=%ld", (long int) (now - ss->booted));
 148     status_reply_put(sr, "pid=%ld", (long int) getpid());
 149 }
 150
 151 struct switch_status *
 152 switch_status_create(const struct ofproto *ofproto)
 153 {
 154     struct switch_status *ss = xzalloc(sizeof *ss);
 155     ss->booted = time_now();
 156     list_init(&ss->categories);
 157     ss->config_cat = switch_status_register(ss, "config", config_status_cb,
 158                                             (void *) ofproto);
 159     ss->switch_cat = switch_status_register(ss, "switch", switch_status_cb,
 160                                             ss);
 161     return ss;
 162 }
 163
 164 void
 165 switch_status_destroy(struct switch_status *ss)
 166 {
 167     if (ss) {
 168         /* Orphan any remaining categories, so that unregistering them later
 169          * won't write to bad memory. */
 170         struct status_category *c, *next;
 171         LIST_FOR_EACH_SAFE (c, next, node, &ss->categories) {
 172             list_init(&c->node);
 173         }
 174         switch_status_unregister(ss->config_cat);
 175         switch_status_unregister(ss->switch_cat);
 176         free(ss);
 177     }
 178 }
 179
 180 struct status_category *
 181 switch_status_register(struct switch_status *ss,
 182                        const char *category,
 183                        status_cb_func *cb, void *aux)
 184 {
 185     struct status_category *c = xmalloc(sizeof *c);
 186     c->cb = cb;
 187     c->aux = aux;
 188     c->name = xstrdup(category);
 189     list_push_back(&ss->categories, &c->node);
 190     return c;
 191 }
 192
 193 void
 194 switch_status_unregister(struct status_category *c)
 195 {
 196     if (c) {
 197         if (!list_is_empty(&c->node)) {
 198             list_remove(&c->node);
 199         }
 200         free(c->name);
 201         free(c);
 202     }
 203 }
 204
 205 void
 206 status_reply_put(struct status_reply *sr, const char *content, ...)
 207 {
 208     size_t old_length = sr->output.length;
 209     size_t added;
 210     va_list args;
 211
 212     /* Append the status reply to the output. */
 213     ds_put_format(&sr->output, "%s.", sr->category->name);
 214     va_start(args, content);
 215     ds_put_format_valist(&sr->output, content, args);
 216     va_end(args);
 217     if (ds_last(&sr->output) != '\n') {
 218         ds_put_char(&sr->output, '\n');
 219     }
 220
 221     /* Drop what we just added if it doesn't match the request. */
 222     added = sr->output.length - old_length;
 223     if (added < sr->request.length
 224         || memcmp(&sr->output.string[old_length],
 225                   sr->request.string, sr->request.length)) {
 226         ds_truncate(&sr->output, old_length);
 227     }
 228 }