2 * Copyright (c) 2008, 2009, 2010 Nicira Networks.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <arpa/inet.h>
25 #include "dynamic-string.h"
30 #include "openflow/nicira-ext.h"
38 VLOG_DEFINE_THIS_MODULE(status)
40 struct status_category {
43 void (*cb)(struct status_reply *, void *aux);
47 struct switch_status {
49 struct status_category *config_cat;
50 struct status_category *switch_cat;
51 struct list categories;
55 struct status_category *category;
61 switch_status_handle_request(struct switch_status *ss, struct rconn *rconn,
62 struct nicira_header *request)
64 struct status_category *c;
65 struct nicira_header *reply;
66 struct status_reply sr;
70 sr.request.string = (void *) (request + 1);
71 sr.request.length = ntohs(request->header.length) - sizeof *request;
73 LIST_FOR_EACH (c, struct status_category, node, &ss->categories) {
74 if (!memcmp(c->name, sr.request.string,
75 MIN(strlen(c->name), sr.request.length))) {
80 reply = make_openflow_xid(sizeof *reply + sr.output.length,
81 OFPT_VENDOR, request->header.xid, &b);
82 reply->vendor = htonl(NX_VENDOR_ID);
83 reply->subtype = htonl(NXT_STATUS_REPLY);
84 memcpy(reply + 1, sr.output.string, sr.output.length);
85 retval = rconn_send(rconn, b, NULL);
86 if (retval && retval != EAGAIN) {
87 VLOG_WARN("send failed (%s)", strerror(retval));
89 ds_destroy(&sr.output);
94 rconn_status_cb(struct status_reply *sr, void *rconn_)
96 struct rconn *rconn = rconn_;
97 time_t now = time_now();
98 uint32_t remote_ip = rconn_get_remote_ip(rconn);
99 uint32_t local_ip = rconn_get_local_ip(rconn);
101 status_reply_put(sr, "name=%s", rconn_get_target(rconn));
103 status_reply_put(sr, "remote-ip="IP_FMT, IP_ARGS(&remote_ip));
104 status_reply_put(sr, "remote-port=%d",
105 ntohs(rconn_get_remote_port(rconn)));
106 status_reply_put(sr, "local-ip="IP_FMT, IP_ARGS(&local_ip));
107 status_reply_put(sr, "local-port=%d",
108 ntohs(rconn_get_local_port(rconn)));
110 status_reply_put(sr, "state=%s", rconn_get_state(rconn));
111 status_reply_put(sr, "backoff=%d", rconn_get_backoff(rconn));
112 status_reply_put(sr, "probe-interval=%d", rconn_get_probe_interval(rconn));
113 status_reply_put(sr, "is-connected=%s",
114 rconn_is_connected(rconn) ? "true" : "false");
115 status_reply_put(sr, "sent-msgs=%u", rconn_packets_sent(rconn));
116 status_reply_put(sr, "received-msgs=%u", rconn_packets_received(rconn));
117 status_reply_put(sr, "attempted-connections=%u",
118 rconn_get_attempted_connections(rconn));
119 status_reply_put(sr, "successful-connections=%u",
120 rconn_get_successful_connections(rconn));
121 status_reply_put(sr, "last-connection=%ld",
122 (long int) (now - rconn_get_last_connection(rconn)));
123 status_reply_put(sr, "last-received=%ld",
124 (long int) (now - rconn_get_last_received(rconn)));
125 status_reply_put(sr, "time-connected=%lu",
126 rconn_get_total_time_connected(rconn));
127 status_reply_put(sr, "state-elapsed=%u", rconn_get_state_elapsed(rconn));
131 config_status_cb(struct status_reply *sr, void *ofproto_)
133 const struct ofproto *ofproto = ofproto_;
134 uint64_t datapath_id;
136 datapath_id = ofproto_get_datapath_id(ofproto);
138 status_reply_put(sr, "datapath-id=%016"PRIx64, datapath_id);
143 switch_status_cb(struct status_reply *sr, void *ss_)
145 struct switch_status *ss = ss_;
146 time_t now = time_now();
148 status_reply_put(sr, "now=%ld", (long int) now);
149 status_reply_put(sr, "uptime=%ld", (long int) (now - ss->booted));
150 status_reply_put(sr, "pid=%ld", (long int) getpid());
153 struct switch_status *
154 switch_status_create(const struct ofproto *ofproto)
156 struct switch_status *ss = xzalloc(sizeof *ss);
157 ss->booted = time_now();
158 list_init(&ss->categories);
159 ss->config_cat = switch_status_register(ss, "config", config_status_cb,
161 ss->switch_cat = switch_status_register(ss, "switch", switch_status_cb,
167 switch_status_destroy(struct switch_status *ss)
170 /* Orphan any remaining categories, so that unregistering them later
171 * won't write to bad memory. */
172 struct status_category *c, *next;
173 LIST_FOR_EACH_SAFE (c, next,
174 struct status_category, node, &ss->categories) {
177 switch_status_unregister(ss->config_cat);
178 switch_status_unregister(ss->switch_cat);
183 struct status_category *
184 switch_status_register(struct switch_status *ss,
185 const char *category,
186 status_cb_func *cb, void *aux)
188 struct status_category *c = xmalloc(sizeof *c);
191 c->name = xstrdup(category);
192 list_push_back(&ss->categories, &c->node);
197 switch_status_unregister(struct status_category *c)
200 if (!list_is_empty(&c->node)) {
201 list_remove(&c->node);
209 status_reply_put(struct status_reply *sr, const char *content, ...)
211 size_t old_length = sr->output.length;
215 /* Append the status reply to the output. */
216 ds_put_format(&sr->output, "%s.", sr->category->name);
217 va_start(args, content);
218 ds_put_format_valist(&sr->output, content, args);
220 if (ds_last(&sr->output) != '\n') {
221 ds_put_char(&sr->output, '\n');
224 /* Drop what we just added if it doesn't match the request. */
225 added = sr->output.length - old_length;
226 if (added < sr->request.length
227 || memcmp(&sr->output.string[old_length],
228 sr->request.string, sr->request.length)) {
229 ds_truncate(&sr->output, old_length);