lib/netlink-notifier.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013 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 <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 "openvswitch/vlog.h"
  30
  31 VLOG_DEFINE_THIS_MODULE(netlink_notifier);
  32
  33 COVERAGE_DEFINE(nln_changed);
  34
  35 static void nln_report(struct nln *nln, void *change);
  36
  37 struct nln {
  38     struct nl_sock *notify_sock; /* Netlink socket. */
  39     struct ovs_list all_notifiers;   /* All nln notifiers. */
  40     bool has_run;                /* Guard for run and wait functions. */
  41
  42     /* Passed in by nln_create(). */
  43     int multicast_group;         /* Multicast group we listen on. */
  44     int protocol;                /* Protocol passed to nl_sock_create(). */
  45     nln_parse_func *parse;       /* Message parsing function. */
  46     void *change;                /* Change passed to parse. */
  47 };
  48
  49 struct nln_notifier {
  50     struct nln *nln;             /* Parent nln. */
  51
  52     struct ovs_list node;
  53     nln_notify_func *cb;
  54     void *aux;
  55 };
  56
  57 /* Creates an nln handle which may be used to manage change notifications.  The
  58  * created handle will listen for netlink messages on 'multicast_group' using
  59  * netlink protocol 'protocol' (e.g. NETLINK_ROUTE, NETLINK_GENERIC, ...).
  60  * Incoming messages will be parsed with 'parse' which will be passed 'change'
  61  * as an argument. */
  62 struct nln *
  63 nln_create(int protocol, int multicast_group, nln_parse_func *parse,
  64            void *change)
  65 {
  66     struct nln *nln;
  67
  68     nln = xzalloc(sizeof *nln);
  69     nln->notify_sock = NULL;
  70     nln->protocol = protocol;
  71     nln->multicast_group = multicast_group;
  72     nln->parse = parse;
  73     nln->change = change;
  74     nln->has_run = false;
  75
  76     list_init(&nln->all_notifiers);
  77     return nln;
  78 }
  79
  80 /* Destroys 'nln' by freeing any memory it has reserved and closing any sockets
  81  * it has opened.
  82  *
  83  * The caller is responsible for destroying any notifiers created by this
  84  * 'nln' before destroying 'nln'. */
  85 void
  86 nln_destroy(struct nln *nln)
  87 {
  88     if (nln) {
  89         ovs_assert(list_is_empty(&nln->all_notifiers));
  90         nl_sock_destroy(nln->notify_sock);
  91         free(nln);
  92     }
  93 }
  94
  95 /* Registers 'cb' to be called with auxiliary data 'aux' with change
  96  * notifications.  The notifier is stored in 'notifier', which the caller must
  97  * not modify or free.
  98  *
  99  * This is probably not the function you want.  You should probably be using
 100  * message specific notifiers like rtnetlink_link_notifier_register().
 101  *
 102  * Returns an initialized nln_notifier if successful, otherwise NULL. */
 103 struct nln_notifier *
 104 nln_notifier_create(struct nln *nln, nln_notify_func *cb, void *aux)
 105 {
 106     struct nln_notifier *notifier;
 107
 108     if (!nln->notify_sock) {
 109         struct nl_sock *sock;
 110         int error;
 111
 112         error = nl_sock_create(nln->protocol, &sock);
 113         if (!error) {
 114             error = nl_sock_join_mcgroup(sock, nln->multicast_group);
 115         }
 116         if (error) {
 117             nl_sock_destroy(sock);
 118             VLOG_WARN("could not create netlink socket: %s",
 119                       ovs_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                 /* The socket buffer might be full, there could be too many
 186                  * notifications, so it makes sense to call nln_report() */
 187                 nln_report(nln, NULL);
 188                 VLOG_WARN_RL(&rl, "netlink receive buffer overflowed");
 189             } else {
 190                 VLOG_WARN_RL(&rl, "error reading netlink socket: %s",
 191                              ovs_strerror(error));
 192             }
 193             return;
 194         }
 195     }
 196 }
 197
 198 /* Causes poll_block() to wake up when change notifications are ready. */
 199 void
 200 nln_wait(struct nln *nln)
 201 {
 202     nln->has_run = false;
 203     if (nln->notify_sock) {
 204         nl_sock_wait(nln->notify_sock, POLLIN);
 205     }
 206 }
 207
 208 static void
 209 nln_report(struct nln *nln, void *change)
 210 {
 211     struct nln_notifier *notifier;
 212
 213     if (change) {
 214         COVERAGE_INC(nln_changed);
 215     }
 216
 217     LIST_FOR_EACH (notifier, node, &nln->all_notifiers) {
 218         notifier->cb(change, notifier->aux);
 219     }
 220 }