ofproto-dpif: Factor out VLAN splinter flow adjustment into new function.
[openvswitch] / lib / netlink-notifier.c
1 /*
2  * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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 "netlink-notifier.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <poll.h>
24 #include <stdlib.h>
25
26 #include "coverage.h"
27 #include "netlink.h"
28 #include "netlink-socket.h"
29 #include "ofpbuf.h"
30 #include "vlog.h"
31
32 VLOG_DEFINE_THIS_MODULE(netlink_notifier);
33
34 COVERAGE_DEFINE(nln_changed);
35
36 static void nln_report(struct nln *nln, void *change);
37
38 struct nln {
39     struct nl_sock *notify_sock; /* Netlink socket. */
40     struct list all_notifiers;   /* All nln notifiers. */
41     bool has_run;                /* Guard for run and wait functions. */
42
43     /* Passed in by nln_create(). */
44     int multicast_group;         /* Multicast group we listen on. */
45     int protocol;                /* Protocal passed to nl_sock_create(). */
46     nln_parse_func *parse;       /* Message parsing function. */
47     void *change;                /* Change passed to parse. */
48 };
49
50 struct nln_notifier {
51     struct nln *nln;             /* Parent nln. */
52
53     struct list node;
54     nln_notify_func *cb;
55     void *aux;
56 };
57
58 /* Creates an nln handle which may be used to manage change notifications.  The
59  * created handle will listen for netlink messages on 'multicast_group' using
60  * netlink protocol 'protocol' (e.g. NETLINK_ROUTE, NETLINK_GENERIC, ...).
61  * Incoming messages will be parsed with 'parse' which will be passed 'change'
62  * as an argument. */
63 struct nln *
64 nln_create(int protocol, int multicast_group, nln_parse_func *parse,
65            void *change)
66 {
67     struct nln *nln;
68
69     nln = xzalloc(sizeof *nln);
70     nln->notify_sock = NULL;
71     nln->protocol = protocol;
72     nln->multicast_group = multicast_group;
73     nln->parse = parse;
74     nln->change = change;
75     nln->has_run = false;
76
77     list_init(&nln->all_notifiers);
78     return nln;
79 }
80
81 /* Destroys 'nln' by freeing any memory it has reserved and closing any sockets
82  * it has opened.
83  *
84  * The caller is responsible for destroying any notifiers created by this
85  * 'nln' before destroying 'nln'. */
86 void
87 nln_destroy(struct nln *nln)
88 {
89     if (nln) {
90         assert(list_is_empty(&nln->all_notifiers));
91         nl_sock_destroy(nln->notify_sock);
92         free(nln);
93     }
94 }
95
96 /* Registers 'cb' to be called with auxiliary data 'aux' with change
97  * notifications.  The notifier is stored in 'notifier', which the caller must
98  * not modify or free.
99  *
100  * This is probably not the function you want.  You should probably be using
101  * message specific notifiers like rtnetlink_link_notifier_register().
102  *
103  * Returns an initialized nln_notifier if successful, otherwise NULL. */
104 struct nln_notifier *
105 nln_notifier_create(struct nln *nln, nln_notify_func *cb, void *aux)
106 {
107     struct nln_notifier *notifier;
108
109     if (!nln->notify_sock) {
110         struct nl_sock *sock;
111         int error;
112
113         error = nl_sock_create(nln->protocol, &sock);
114         if (!error) {
115             error = nl_sock_join_mcgroup(sock, nln->multicast_group);
116         }
117         if (error) {
118             nl_sock_destroy(sock);
119             VLOG_WARN("could not create netlink socket: %s", strerror(error));
120             return NULL;
121         }
122         nln->notify_sock = sock;
123     } else {
124         /* Catch up on notification work so that the new notifier won't
125          * receive any stale notifications. */
126         nln_run(nln);
127     }
128
129     notifier = xmalloc(sizeof *notifier);
130     list_push_back(&nln->all_notifiers, &notifier->node);
131     notifier->cb = cb;
132     notifier->aux = aux;
133     notifier->nln = nln;
134     return notifier;
135 }
136
137 /* Destroys 'notifier', which must have previously been created with
138  * nln_notifier_register(). */
139 void
140 nln_notifier_destroy(struct nln_notifier *notifier)
141 {
142     if (notifier) {
143         struct nln *nln = notifier->nln;
144
145         list_remove(&notifier->node);
146         if (list_is_empty(&nln->all_notifiers)) {
147             nl_sock_destroy(nln->notify_sock);
148             nln->notify_sock = NULL;
149         }
150         free(notifier);
151     }
152 }
153
154 /* Calls all of the registered notifiers, passing along any as-yet-unreported
155  * change events. */
156 void
157 nln_run(struct nln *nln)
158 {
159     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
160
161     if (!nln->notify_sock || nln->has_run) {
162         return;
163     }
164
165     nln->has_run = true;
166     for (;;) {
167         uint64_t buf_stub[4096 / 8];
168         struct ofpbuf buf;
169         int error;
170
171         ofpbuf_use_stub(&buf, buf_stub, sizeof buf_stub);
172         error = nl_sock_recv(nln->notify_sock, &buf, false);
173         if (!error) {
174             if (nln->parse(&buf, nln->change)) {
175                 nln_report(nln, nln->change);
176             } else {
177                 VLOG_WARN_RL(&rl, "received bad netlink message");
178                 nln_report(nln, NULL);
179             }
180             ofpbuf_uninit(&buf);
181         } else if (error == EAGAIN) {
182             return;
183         } else {
184             if (error == ENOBUFS) {
185                 VLOG_WARN_RL(&rl, "netlink receive buffer overflowed");
186             } else {
187                 VLOG_WARN_RL(&rl, "error reading netlink socket: %s",
188                              strerror(error));
189             }
190             nln_report(nln, NULL);
191         }
192     }
193 }
194
195 /* Causes poll_block() to wake up when change notifications are ready. */
196 void
197 nln_wait(struct nln *nln)
198 {
199     nln->has_run = false;
200     if (nln->notify_sock) {
201         nl_sock_wait(nln->notify_sock, POLLIN);
202     }
203 }
204
205 static void
206 nln_report(struct nln *nln, void *change)
207 {
208     struct nln_notifier *notifier;
209
210     if (change) {
211         COVERAGE_INC(nln_changed);
212     }
213
214     LIST_FOR_EACH (notifier, node, &nln->all_notifiers) {
215         notifier->cb(change, notifier->aux);
216     }
217 }