/*
* lib/cache_mngr.c Cache Manager
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation version 2.1
* of the License.
*
* Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
*/
/**
* @ingroup cache_mngt
* @defgroup cache_mngr Manager
* @brief Helps keeping caches up to date.
*
* The purpose of a cache manager is to keep track of caches and
* automatically receive event notifications to keep the caches
* up to date with the kernel state. Each manager has exactly one
* netlink socket assigned which limits the scope of each manager
* to exactly one netlink family. Therefore all caches committed
* to a manager must be part of the same netlink family. Due to the
* nature of a manager, it is not possible to have a cache maintain
* two instances of the same cache type. The socket is subscribed
* to the event notification group of each cache and also put into
* non-blocking mode. Functions exist to poll() on the socket to
* wait for new events to be received.
*
* @code
* App libnl Kernel
* | |
* +-----------------+ [ notification, link change ]
* | | Cache Manager | | [ (IFF_UP | IFF_RUNNING) ]
* | | |
* | | +------------+| | | [ notification, new addr ]
* <-------|---| route/link |<-------(async)--+ [ 10.0.1.1/32 dev eth1 ]
* | | +------------+| | |
* | +------------+| |
* <---|---|---| route/addr |<------|-(async)--------------+
* | +------------+|
* | | +------------+| |
* <-------|---| ... ||
* | | +------------+| |
* +-----------------+
* | |
* @endcode
*
* @par 1) Creating a new cache manager
* @code
* struct nl_cache_mngr *mngr;
*
* // Allocate a new cache manager for RTNETLINK and automatically
* // provide the caches added to the manager.
* mngr = nl_cache_mngr_alloc(NETLINK_ROUTE, NL_AUTO_PROVIDE);
* @endcode
*
* @par 2) Keep track of a cache
* @code
* struct nl_cache *cache;
*
* // Create a new cache for links/interfaces and ask the manager to
* // keep it up to date for us. This will trigger a full dump request
* // to initially fill the cache.
* cache = nl_cache_mngr_add(mngr, "route/link");
* @endcode
*
* @par 3) Make the manager receive updates
* @code
* // Give the manager the ability to receive updates, will call poll()
* // with a timeout of 5 seconds.
* if (nl_cache_mngr_poll(mngr, 5000) > 0) {
* // Manager received at least one update, dump cache?
* nl_cache_dump(cache, ...);
* }
* @endcode
*
* @par 4) Release cache manager
* @code
* nl_cache_mngr_free(mngr);
* @endcode
* @{
*/
#include <netlink-local.h>
#include <netlink/netlink.h>
#include <netlink/cache.h>
#include <netlink/utils.h>
static int include_cb(struct nl_object *obj, struct nl_parser_param *p)
{
struct nl_cache_assoc *ca = p->pp_arg;
NL_DBG(2, "Including object %p into cache %p\n", obj, ca->ca_cache);
#ifdef NL_DEBUG
if (nl_debug >= 4)
nl_object_dump(obj, &nl_debug_dp);
#endif
return nl_cache_include(ca->ca_cache, obj, ca->ca_change, ca->ca_change_data);
}
static int event_input(struct nl_msg *msg, void *arg)
{
struct nl_cache_mngr *mngr = arg;
int protocol = nlmsg_get_proto(msg);
int type = nlmsg_hdr(msg)->nlmsg_type;
struct nl_cache_ops *ops;
int i, n;
struct nl_parser_param p = {
.pp_cb = include_cb,
};
NL_DBG(2, "Cache manager %p, handling new message %p as event\n",
mngr, msg);
#ifdef NL_DEBUG
if (nl_debug >= 4)
nl_msg_dump(msg, stderr);
#endif
if (mngr->cm_protocol != protocol)
BUG();
for (i = 0; i < mngr->cm_nassocs; i++) {
if (mngr->cm_assocs[i].ca_cache) {
ops = mngr->cm_assocs[i].ca_cache->c_ops;
for (n = 0; ops->co_msgtypes[n].mt_id >= 0; n++)
if (ops->co_msgtypes[n].mt_id == type)
goto found;
}
}
return NL_SKIP;
found:
NL_DBG(2, "Associated message %p to cache %p\n",
msg, mngr->cm_assocs[i].ca_cache);
p.pp_arg = &mngr->cm_assocs[i];
return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
}
/**
* Allocate new cache manager
* @arg sk Netlink socket.
* @arg protocol Netlink Protocol this manager is used for
* @arg flags Flags
*
* @return Newly allocated cache manager or NULL on failure.
*/
int nl_cache_mngr_alloc(struct nl_sock *sk, int protocol, int flags,
struct nl_cache_mngr **result)
{
struct nl_cache_mngr *mngr;
int err = -NLE_NOMEM;
if (sk == NULL)
BUG();
mngr = calloc(1, sizeof(*mngr));
if (!mngr)
goto errout;
mngr->cm_handle = sk;
mngr->cm_nassocs = 32;
mngr->cm_protocol = protocol;
mngr->cm_flags = flags;
mngr->cm_assocs = calloc(mngr->cm_nassocs,
sizeof(struct nl_cache_assoc));
if (!mngr->cm_assocs)
goto errout;
nl_socket_modify_cb(mngr->cm_handle, NL_CB_VALID, NL_CB_CUSTOM,
event_input, mngr);
/* Required to receive async event notifications */
nl_socket_disable_seq_check(mngr->cm_handle);
if ((err = nl_connect(mngr->cm_handle, protocol) < 0))
goto errout;
if ((err = nl_socket_set_nonblocking(mngr->cm_handle) < 0))
goto errout;
NL_DBG(1, "Allocated cache manager %p, protocol %d, %d caches\n",
mngr, protocol, mngr->cm_nassocs);
*result = mngr;
return 0;
errout:
nl_cache_mngr_free(mngr);
return err;
}
/**
* Add cache responsibility to cache manager
* @arg mngr Cache manager.
* @arg name Name of cache to keep track of
* @arg cb Function to be called upon changes.
* @arg result Pointer to store added cache.
*
* Allocates a new cache of the specified type and adds it to the manager.
* The operation will trigger a full dump request from the kernel to
* initially fill the contents of the cache. The manager will subscribe
* to the notification group of the cache to keep track of any further
* changes.
*
* @return 0 on success or a negative error code.
*/
int nl_cache_mngr_add(struct nl_cache_mngr *mngr, const char *name,
change_func_t cb, void *data, struct nl_cache **result)
{
struct nl_cache_ops *ops;
struct nl_cache *cache;
struct nl_af_group *grp;
int err, i;
ops = nl_cache_ops_lookup(name);
if (!ops)
return -NLE_NOCACHE;
if (ops->co_protocol != mngr->cm_protocol)
return -NLE_PROTO_MISMATCH;
if (ops->co_groups == NULL)
return -NLE_OPNOTSUPP;
for (i = 0; i < mngr->cm_nassocs; i++)
if (mngr->cm_assocs[i].ca_cache &&
mngr->cm_assocs[i].ca_cache->c_ops == ops)
return -NLE_EXIST;
retry:
for (i = 0; i < mngr->cm_nassocs; i++)
if (!mngr->cm_assocs[i].ca_cache)
break;
if (i >= mngr->cm_nassocs) {
mngr->cm_nassocs += 16;
mngr->cm_assocs = realloc(mngr->cm_assocs,
mngr->cm_nassocs *
sizeof(struct nl_cache_assoc));
if (mngr->cm_assocs == NULL)
return -NLE_NOMEM;
else {
NL_DBG(1, "Increased capacity of cache manager %p " \
"to %d\n", mngr, mngr->cm_nassocs);
goto retry;
}
}
cache = nl_cache_alloc(ops);
if (!cache)
return -NLE_NOMEM;
for (grp = ops->co_groups; grp->ag_group; grp++) {
err = nl_socket_add_membership(mngr->cm_handle, grp->ag_group);
if (err < 0)
goto errout_free_cache;
}
err = nl_cache_refill(mngr->cm_handle, cache);
if (err < 0)
goto errout_drop_membership;
mngr->cm_assocs[i].ca_cache = cache;
mngr->cm_assocs[i].ca_change = cb;
mngr->cm_assocs[i].ca_change_data = data;
if (mngr->cm_flags & NL_AUTO_PROVIDE)
nl_cache_mngt_provide(cache);
NL_DBG(1, "Added cache %p <%s> to cache manager %p\n",
cache, nl_cache_name(cache), mngr);
*result = cache;
return 0;
errout_drop_membership:
for (grp = ops->co_groups; grp->ag_group; grp++)
nl_socket_drop_membership(mngr->cm_handle, grp->ag_group);
errout_free_cache:
nl_cache_free(cache);
return err;
}
/**
* Get file descriptor
* @arg mngr Cache Manager
*
* Get the file descriptor of the socket associated to the manager.
* This can be used to change socket options or monitor activity
* using poll()/select().
*/
int nl_cache_mngr_get_fd(struct nl_cache_mngr *mngr)
{
return nl_socket_get_fd(mngr->cm_handle);
}
/**
* Check for event notifications
* @arg mngr Cache Manager
* @arg timeout Upper limit poll() will block, in milliseconds.
*
* Causes poll() to be called to check for new event notifications
* being available. Automatically receives and handles available
* notifications.
*
* This functionally is ideally called regularly during an idle
* period.
*
* @return A positive value if at least one update was handled, 0
* for none, or a negative error code.
*/
int nl_cache_mngr_poll(struct nl_cache_mngr *mngr, int timeout)
{
int ret;
struct pollfd fds = {
.fd = nl_socket_get_fd(mngr->cm_handle),
.events = POLLIN,
};
NL_DBG(3, "Cache manager %p, poll() fd %d\n", mngr, fds.fd);
ret = poll(&fds, 1, timeout);
NL_DBG(3, "Cache manager %p, poll() returned %d\n", mngr, ret);
if (ret < 0)
return -nl_syserr2nlerr(errno);
if (ret == 0)
return 0;
return nl_cache_mngr_data_ready(mngr);
}
/**
* Receive available event notifications
* @arg mngr Cache manager
*
* This function can be called if the socket associated to the manager
* contains updates to be received. This function should not be used
* if nl_cache_mngr_poll() is used.
*
* @return A positive value if at least one update was handled, 0
* for none, or a negative error code.
*/
int nl_cache_mngr_data_ready(struct nl_cache_mngr *mngr)
{
int err;
err = nl_recvmsgs_default(mngr->cm_handle);
if (err < 0)
return err;
return 1;
}
/**
* Free cache manager and all caches.
* @arg mngr Cache manager.
*
* Release all resources after usage of a cache manager.
*/
void nl_cache_mngr_free(struct nl_cache_mngr *mngr)
{
int i;
if (!mngr)
return;
if (mngr->cm_handle)
nl_close(mngr->cm_handle);
for (i = 0; i < mngr->cm_nassocs; i++)
if (mngr->cm_assocs[i].ca_cache)
nl_cache_free(mngr->cm_assocs[i].ca_cache);
free(mngr->cm_assocs);
free(mngr);
NL_DBG(1, "Cache manager %p freed\n", mngr);
}
/** @} */