ofp-print: Don't print priority for flow stats requests.
[openvswitch] / lib / rtnetlink.c
1 /*
2  * Copyright (c) 2009, 2010, 2011 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
19 #include "rtnetlink.h"
20
21 #include <errno.h>
22 #include <poll.h>
23 #include <stdlib.h>
24
25 #include "coverage.h"
26 #include "netlink.h"
27 #include "netlink-socket.h"
28 #include "ofpbuf.h"
29 #include "vlog.h"
30
31 VLOG_DEFINE_THIS_MODULE(rtnetlink);
32
33 COVERAGE_DEFINE(rtnetlink_changed);
34
35 static void rtnetlink_report(struct rtnetlink *rtn, void *change);
36
37 struct rtnetlink {
38     struct nl_sock *notify_sock; /* Rtnetlink socket. */
39     struct list all_notifiers;   /* All rtnetlink notifiers. */
40
41     /* Passed in by rtnetlink_create(). */
42     int multicast_group;         /* Multicast group we listen on. */
43     rtnetlink_parse_func *parse; /* Message parsing function. */
44     void *change;                /* Change passed to parse. */
45 };
46
47 /* Creates an rtnetlink handle which may be used to manage change
48  * notifications.  The created handle will listen for rtnetlink messages on
49  * 'multicast_group'.  Incoming messages will be parsed with 'parse' which will
50  * be passed 'change' as an argument. */
51 struct rtnetlink *
52 rtnetlink_create(int multicast_group, rtnetlink_parse_func *parse,
53                  void *change)
54 {
55     struct rtnetlink *rtn;
56
57     rtn                  = xzalloc(sizeof *rtn);
58     rtn->notify_sock     = 0;
59     rtn->multicast_group = multicast_group;
60     rtn->parse           = parse;
61     rtn->change          = change;
62
63     list_init(&rtn->all_notifiers);
64     return rtn;
65 }
66
67 /* Destroys 'rtn' by freeing any memory it has reserved and closing any sockets
68  * it has opened. */
69 void
70 rtnetlink_destroy(struct rtnetlink *rtn)
71 {
72     if (rtn) {
73         nl_sock_destroy(rtn->notify_sock);
74         free(rtn);
75     }
76 }
77
78 /* Registers 'cb' to be called with auxiliary data 'aux' with change
79  * notifications.  The notifier is stored in 'notifier', which the caller must
80  * not modify or free.
81  *
82  * This is probably not the function you want.  You should probably be using
83  * message specific notifiers like rtnetlink_link_notifier_register().
84  *
85  * Returns 0 if successful, otherwise a positive errno value. */
86 int
87 rtnetlink_notifier_register(struct rtnetlink *rtn,
88                             struct rtnetlink_notifier *notifier,
89                             rtnetlink_notify_func *cb, void *aux)
90 {
91     if (!rtn->notify_sock) {
92         struct nl_sock *sock;
93         int error;
94
95         error = nl_sock_create(NETLINK_ROUTE, &sock);
96         if (!error) {
97             error = nl_sock_join_mcgroup(sock, rtn->multicast_group);
98         }
99         if (error) {
100             nl_sock_destroy(sock);
101             VLOG_WARN("could not create rtnetlink socket: %s",
102                       strerror(error));
103             return error;
104         }
105         rtn->notify_sock = sock;
106     } else {
107         /* Catch up on notification work so that the new notifier won't
108          * receive any stale notifications. */
109         rtnetlink_notifier_run(rtn);
110     }
111
112     list_push_back(&rtn->all_notifiers, &notifier->node);
113     notifier->cb = cb;
114     notifier->aux = aux;
115     return 0;
116 }
117
118 /* Cancels notification on 'notifier', which must have previously been
119  * registered with rtnetlink_notifier_register(). */
120 void
121 rtnetlink_notifier_unregister(struct rtnetlink *rtn,
122                               struct rtnetlink_notifier *notifier)
123 {
124     list_remove(&notifier->node);
125     if (list_is_empty(&rtn->all_notifiers)) {
126         nl_sock_destroy(rtn->notify_sock);
127         rtn->notify_sock = NULL;
128     }
129 }
130
131 /* Calls all of the registered notifiers, passing along any as-yet-unreported
132  * change events. */
133 void
134 rtnetlink_notifier_run(struct rtnetlink *rtn)
135 {
136     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
137
138     if (!rtn->notify_sock) {
139         return;
140     }
141
142     for (;;) {
143         struct ofpbuf *buf;
144         int error;
145
146         error = nl_sock_recv(rtn->notify_sock, &buf, false);
147         if (!error) {
148             if (rtn->parse(buf, rtn->change)) {
149                 rtnetlink_report(rtn, rtn->change);
150             } else {
151                 VLOG_WARN_RL(&rl, "received bad rtnl message");
152                 rtnetlink_report(rtn, NULL);
153             }
154             ofpbuf_delete(buf);
155         } else if (error == EAGAIN) {
156             return;
157         } else {
158             if (error == ENOBUFS) {
159                 VLOG_WARN_RL(&rl, "rtnetlink receive buffer overflowed");
160             } else {
161                 VLOG_WARN_RL(&rl, "error reading rtnetlink socket: %s",
162                              strerror(error));
163             }
164             rtnetlink_report(rtn, NULL);
165         }
166     }
167 }
168
169 /* Causes poll_block() to wake up when change notifications are ready. */
170 void
171 rtnetlink_notifier_wait(struct rtnetlink *rtn)
172 {
173     if (rtn->notify_sock) {
174         nl_sock_wait(rtn->notify_sock, POLLIN);
175     }
176 }
177
178 static void
179 rtnetlink_report(struct rtnetlink *rtn, void *change)
180 {
181     struct rtnetlink_notifier *notifier;
182
183     if (change) {
184         COVERAGE_INC(rtnetlink_changed);
185     }
186
187     LIST_FOR_EACH (notifier, node, &rtn->all_notifiers) {
188         notifier->cb(change, notifier->aux);
189     }
190 }
191