![Neil Horman](/assets/img/avatar_default.png)
When I initially implemented this protocol, I disregarded the use of netlink attribute headers, thinking for my purposes they weren't needed. I've come to find out that, as I'm starting to work with sending down messages with associated data (like config messages), the kernel code spits out warnings about trailing data in a netlink skb that doesn't have an associated header on it. As such, I'm going to start including attribute headers in my netlink transaction, and so for completeness, I should likely include them on messages bound from the kernel to user space. This patch adds that header to the kernel, and bumps the protocol version accordingly Signed-off-by: Neil Horman <nhorman@tuxdriver.com> Signed-off-by: David S. Miller <davem@davemloft.net>
271 lines
5.7 KiB
C
271 lines
5.7 KiB
C
/*
|
|
* Monitoring code for network dropped packet alerts
|
|
*
|
|
* Copyright (C) 2009 Neil Horman <nhorman@tuxdriver.com>
|
|
*/
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/string.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/inetdevice.h>
|
|
#include <linux/inet.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/netpoll.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/types.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/netlink.h>
|
|
#include <linux/net_dropmon.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/bitops.h>
|
|
#include <net/genetlink.h>
|
|
|
|
#include <trace/skb.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#define TRACE_ON 1
|
|
#define TRACE_OFF 0
|
|
|
|
static void send_dm_alert(struct work_struct *unused);
|
|
|
|
|
|
/*
|
|
* Globals, our netlink socket pointer
|
|
* and the work handle that will send up
|
|
* netlink alerts
|
|
*/
|
|
struct sock *dm_sock;
|
|
|
|
struct per_cpu_dm_data {
|
|
struct work_struct dm_alert_work;
|
|
struct sk_buff *skb;
|
|
atomic_t dm_hit_count;
|
|
struct timer_list send_timer;
|
|
};
|
|
|
|
static struct genl_family net_drop_monitor_family = {
|
|
.id = GENL_ID_GENERATE,
|
|
.hdrsize = 0,
|
|
.name = "NET_DM",
|
|
.version = 2,
|
|
.maxattr = NET_DM_CMD_MAX,
|
|
};
|
|
|
|
static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
|
|
|
|
static int dm_hit_limit = 64;
|
|
static int dm_delay = 1;
|
|
|
|
|
|
static void reset_per_cpu_data(struct per_cpu_dm_data *data)
|
|
{
|
|
size_t al;
|
|
struct net_dm_alert_msg *msg;
|
|
struct nlattr *nla;
|
|
|
|
al = sizeof(struct net_dm_alert_msg);
|
|
al += dm_hit_limit * sizeof(struct net_dm_drop_point);
|
|
al += sizeof(struct nlattr);
|
|
|
|
data->skb = genlmsg_new(al, GFP_KERNEL);
|
|
genlmsg_put(data->skb, 0, 0, &net_drop_monitor_family,
|
|
0, NET_DM_CMD_ALERT);
|
|
nla = nla_reserve(data->skb, NLA_UNSPEC, sizeof(struct net_dm_alert_msg));
|
|
msg = nla_data(nla);
|
|
memset(msg, 0, al);
|
|
atomic_set(&data->dm_hit_count, dm_hit_limit);
|
|
}
|
|
|
|
static void send_dm_alert(struct work_struct *unused)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct per_cpu_dm_data *data = &__get_cpu_var(dm_cpu_data);
|
|
|
|
/*
|
|
* Grab the skb we're about to send
|
|
*/
|
|
skb = data->skb;
|
|
|
|
/*
|
|
* Replace it with a new one
|
|
*/
|
|
reset_per_cpu_data(data);
|
|
|
|
/*
|
|
* Ship it!
|
|
*/
|
|
genlmsg_multicast(skb, 0, NET_DM_GRP_ALERT, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
/*
|
|
* This is the timer function to delay the sending of an alert
|
|
* in the event that more drops will arrive during the
|
|
* hysteresis period. Note that it operates under the timer interrupt
|
|
* so we don't need to disable preemption here
|
|
*/
|
|
static void sched_send_work(unsigned long unused)
|
|
{
|
|
struct per_cpu_dm_data *data = &__get_cpu_var(dm_cpu_data);
|
|
|
|
schedule_work(&data->dm_alert_work);
|
|
}
|
|
|
|
static void trace_kfree_skb_hit(struct sk_buff *skb, void *location)
|
|
{
|
|
struct net_dm_alert_msg *msg;
|
|
struct nlmsghdr *nlh;
|
|
struct nlattr *nla;
|
|
int i;
|
|
struct per_cpu_dm_data *data = &__get_cpu_var(dm_cpu_data);
|
|
|
|
|
|
if (!atomic_add_unless(&data->dm_hit_count, -1, 0)) {
|
|
/*
|
|
* we're already at zero, discard this hit
|
|
*/
|
|
goto out;
|
|
}
|
|
|
|
nlh = (struct nlmsghdr *)data->skb->data;
|
|
nla = genlmsg_data(nlmsg_data(nlh));
|
|
msg = nla_data(nla);
|
|
for (i = 0; i < msg->entries; i++) {
|
|
if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
|
|
msg->points[i].count++;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We need to create a new entry
|
|
*/
|
|
__nla_reserve_nohdr(data->skb, sizeof(struct net_dm_drop_point));
|
|
nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
|
|
memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
|
|
msg->points[msg->entries].count = 1;
|
|
msg->entries++;
|
|
|
|
if (!timer_pending(&data->send_timer)) {
|
|
data->send_timer.expires = jiffies + dm_delay * HZ;
|
|
add_timer_on(&data->send_timer, smp_processor_id());
|
|
}
|
|
|
|
out:
|
|
return;
|
|
}
|
|
|
|
static int set_all_monitor_traces(int state)
|
|
{
|
|
int rc = 0;
|
|
|
|
switch (state) {
|
|
case TRACE_ON:
|
|
rc |= register_trace_kfree_skb(trace_kfree_skb_hit);
|
|
break;
|
|
case TRACE_OFF:
|
|
rc |= unregister_trace_kfree_skb(trace_kfree_skb_hit);
|
|
|
|
tracepoint_synchronize_unregister();
|
|
break;
|
|
default:
|
|
rc = 1;
|
|
break;
|
|
}
|
|
|
|
if (rc)
|
|
return -EINPROGRESS;
|
|
return rc;
|
|
}
|
|
|
|
|
|
static int net_dm_cmd_config(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
static int net_dm_cmd_trace(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
switch (info->genlhdr->cmd) {
|
|
case NET_DM_CMD_START:
|
|
return set_all_monitor_traces(TRACE_ON);
|
|
break;
|
|
case NET_DM_CMD_STOP:
|
|
return set_all_monitor_traces(TRACE_OFF);
|
|
break;
|
|
}
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
|
|
static struct genl_ops dropmon_ops[] = {
|
|
{
|
|
.cmd = NET_DM_CMD_CONFIG,
|
|
.doit = net_dm_cmd_config,
|
|
},
|
|
{
|
|
.cmd = NET_DM_CMD_START,
|
|
.doit = net_dm_cmd_trace,
|
|
},
|
|
{
|
|
.cmd = NET_DM_CMD_STOP,
|
|
.doit = net_dm_cmd_trace,
|
|
},
|
|
};
|
|
|
|
static int __init init_net_drop_monitor(void)
|
|
{
|
|
int cpu;
|
|
int rc, i, ret;
|
|
struct per_cpu_dm_data *data;
|
|
printk(KERN_INFO "Initalizing network drop monitor service\n");
|
|
|
|
if (sizeof(void *) > 8) {
|
|
printk(KERN_ERR "Unable to store program counters on this arch, Drop monitor failed\n");
|
|
return -ENOSPC;
|
|
}
|
|
|
|
if (genl_register_family(&net_drop_monitor_family) < 0) {
|
|
printk(KERN_ERR "Could not create drop monitor netlink family\n");
|
|
return -EFAULT;
|
|
}
|
|
|
|
rc = -EFAULT;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dropmon_ops); i++) {
|
|
ret = genl_register_ops(&net_drop_monitor_family,
|
|
&dropmon_ops[i]);
|
|
if (ret) {
|
|
printk(KERN_CRIT "failed to register operation %d\n",
|
|
dropmon_ops[i].cmd);
|
|
goto out_unreg;
|
|
}
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
for_each_present_cpu(cpu) {
|
|
data = &per_cpu(dm_cpu_data, cpu);
|
|
reset_per_cpu_data(data);
|
|
INIT_WORK(&data->dm_alert_work, send_dm_alert);
|
|
init_timer(&data->send_timer);
|
|
data->send_timer.data = cpu;
|
|
data->send_timer.function = sched_send_work;
|
|
}
|
|
goto out;
|
|
|
|
out_unreg:
|
|
genl_unregister_family(&net_drop_monitor_family);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
late_initcall(init_net_drop_monitor);
|