tcp: add generic netlink support for tcp_metrics

Add support for genl "tcp_metrics". No locking is changed, only that now we can unlink and delete entries after grace period. We implement get/del for single entry and dump to support show/flush filtering in user space. Del without address attribute causes flush for all addresses, sadly under genl_mutex. v2: - remove rcu_assign_pointer as suggested by Eric Dumazet, it is not needed because there are no other writes under lock - move the flushing code in tcp_metrics_flush_all v3: - remove synchronize_rcu on flush as suggested by Eric Dumazet Signed-off-by: Julian Anastasov <ja@ssi.bg> Signed-off-by: David S. Miller <davem@davemloft.net>
author: Julian Anastasov <ja@ssi.bg> 2012-09-04 07:03:15 -0400
committer: David S. Miller <davem@davemloft.net> 2012-09-05 15:15:02 -0400
commit: d23ff701643a4a725e2c7a8ba2d567d39daa29ea (patch)
tree: 039dbda9d59c1e18df6a89f600226924d452fbed /net/ipv4/tcp_metrics.c
parent: ab868256f8d6095e7200d928fcc054b66d0f13a3 (diff)
1 files changed, 341 insertions, 13 deletions
diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c
index 0abe67bb4d3a..988edb63ee73 100644
--- a/net/ipv4/tcp_metrics.c
+++ b/net/ipv4/tcp_metrics.c
@@ -8,6 +8,7 @@
 #include <linux/init.h>
 #include <linux/tcp.h>
 #include <linux/hash.h>
+#include <linux/tcp_metrics.h>
 #include <net/inet_connection_sock.h>
 #include <net/net_namespace.h>
@@ -17,20 +18,10 @@
 #include <net/ipv6.h>
 #include <net/dst.h>
 #include <net/tcp.h>
+#include <net/genetlink.h>
 int sysctl_tcp_nometrics_save __read_mostly;
-enum tcp_metric_index {
-        TCP_METRIC_RTT,
-        TCP_METRIC_RTTVAR,
-        TCP_METRIC_SSTHRESH,
-        TCP_METRIC_CWND,
-        TCP_METRIC_REORDERING,
-        /* Always last.  */
-        TCP_METRIC_MAX,
-};
 struct tcp_fastopen_metrics {
        u16     mss;
        u16     syn_loss:10;            /* Recurring Fast Open SYN losses */
@@ -45,8 +36,10 @@ struct tcp_metrics_block {
        u32                             tcpm_ts;
        u32                             tcpm_ts_stamp;
        u32                             tcpm_lock;
-        u32                             tcpm_vals[TCP_METRIC_MAX];
+        u32                             tcpm_vals[TCP_METRIC_MAX + 1];
        struct tcp_fastopen_metrics     tcpm_fastopen;
+        struct rcu_head                 rcu_head;
 };
 static bool tcp_metric_locked(struct tcp_metrics_block *tm,
@@ -690,6 +683,325 @@ void tcp_fastopen_cache_set(struct sock *sk, u16 mss,
        rcu_read_unlock();
 }
+static struct genl_family tcp_metrics_nl_family = {
+        .id             = GENL_ID_GENERATE,
+        .hdrsize        = 0,
+        .name           = TCP_METRICS_GENL_NAME,
+        .version        = TCP_METRICS_GENL_VERSION,
+        .maxattr        = TCP_METRICS_ATTR_MAX,
+        .netnsok        = true,
+};
+static struct nla_policy tcp_metrics_nl_policy[TCP_METRICS_ATTR_MAX + 1] = {
+        [TCP_METRICS_ATTR_ADDR_IPV4]    = { .type = NLA_U32, },
+        [TCP_METRICS_ATTR_ADDR_IPV6]    = { .type = NLA_BINARY,
+                                            .len = sizeof(struct in6_addr), },
+        /* Following attributes are not received for GET/DEL,
+         * we keep them for reference
+         */
+#if 0
+        [TCP_METRICS_ATTR_AGE]          = { .type = NLA_MSECS, },
+        [TCP_METRICS_ATTR_TW_TSVAL]     = { .type = NLA_U32, },
+        [TCP_METRICS_ATTR_TW_TS_STAMP]  = { .type = NLA_S32, },
+        [TCP_METRICS_ATTR_VALS]         = { .type = NLA_NESTED, },
+        [TCP_METRICS_ATTR_FOPEN_MSS]    = { .type = NLA_U16, },
+        [TCP_METRICS_ATTR_FOPEN_SYN_DROPS]      = { .type = NLA_U16, },
+        [TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS]    = { .type = NLA_MSECS, },
+        [TCP_METRICS_ATTR_FOPEN_COOKIE] = { .type = NLA_BINARY,
+                                            .len = TCP_FASTOPEN_COOKIE_MAX, },
+#endif
+};
+/* Add attributes, caller cancels its header on failure */
+static int tcp_metrics_fill_info(struct sk_buff *msg,
+                                 struct tcp_metrics_block *tm)
+{
+        struct nlattr *nest;
+        int i;
+        switch (tm->tcpm_addr.family) {
+        case AF_INET:
+                if (nla_put_be32(msg, TCP_METRICS_ATTR_ADDR_IPV4,
+                                tm->tcpm_addr.addr.a4) < 0)
+                        goto nla_put_failure;
+                break;
+        case AF_INET6:
+                if (nla_put(msg, TCP_METRICS_ATTR_ADDR_IPV6, 16,
+                            tm->tcpm_addr.addr.a6) < 0)
+                        goto nla_put_failure;
+                break;
+        default:
+                return -EAFNOSUPPORT;
+        }
+        if (nla_put_msecs(msg, TCP_METRICS_ATTR_AGE,
+                          jiffies - tm->tcpm_stamp) < 0)
+                goto nla_put_failure;
+        if (tm->tcpm_ts_stamp) {
+                if (nla_put_s32(msg, TCP_METRICS_ATTR_TW_TS_STAMP,
+                                (s32) (get_seconds() - tm->tcpm_ts_stamp)) < 0)
+                        goto nla_put_failure;
+                if (nla_put_u32(msg, TCP_METRICS_ATTR_TW_TSVAL,
+                                tm->tcpm_ts) < 0)
+                        goto nla_put_failure;
+        }
+        {
+                int n = 0;
+                nest = nla_nest_start(msg, TCP_METRICS_ATTR_VALS);
+                if (!nest)
+                        goto nla_put_failure;
+                for (i = 0; i < TCP_METRIC_MAX + 1; i++) {
+                        if (!tm->tcpm_vals[i])
+                                continue;
+                        if (nla_put_u32(msg, i + 1, tm->tcpm_vals[i]) < 0)
+                                goto nla_put_failure;
+                        n++;
+                }
+                if (n)
+                        nla_nest_end(msg, nest);
+                else
+                        nla_nest_cancel(msg, nest);
+        }
+        {
+                struct tcp_fastopen_metrics tfom_copy[1], *tfom;
+                unsigned int seq;
+                do {
+                        seq = read_seqbegin(&fastopen_seqlock);
+                        tfom_copy[0] = tm->tcpm_fastopen;
+                } while (read_seqretry(&fastopen_seqlock, seq));
+                tfom = tfom_copy;
+                if (tfom->mss &&
+                    nla_put_u16(msg, TCP_METRICS_ATTR_FOPEN_MSS,
+                                tfom->mss) < 0)
+                        goto nla_put_failure;
+                if (tfom->syn_loss &&
+                    (nla_put_u16(msg, TCP_METRICS_ATTR_FOPEN_SYN_DROPS,
+                                tfom->syn_loss) < 0 ||
+                     nla_put_msecs(msg, TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS,
+                                jiffies - tfom->last_syn_loss) < 0))
+                        goto nla_put_failure;
+                if (tfom->cookie.len > 0 &&
+                    nla_put(msg, TCP_METRICS_ATTR_FOPEN_COOKIE,
+                            tfom->cookie.len, tfom->cookie.val) < 0)
+                        goto nla_put_failure;
+        }
+        return 0;
+nla_put_failure:
+        return -EMSGSIZE;
+}
+static int tcp_metrics_dump_info(struct sk_buff *skb,
+                                 struct netlink_callback *cb,
+                                 struct tcp_metrics_block *tm)
+{
+        void *hdr;
+        hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
+                          &tcp_metrics_nl_family, NLM_F_MULTI,
+                          TCP_METRICS_CMD_GET);
+        if (!hdr)
+                return -EMSGSIZE;
+        if (tcp_metrics_fill_info(skb, tm) < 0)
+                goto nla_put_failure;
+        return genlmsg_end(skb, hdr);
+nla_put_failure:
+        genlmsg_cancel(skb, hdr);
+        return -EMSGSIZE;
+}
+static int tcp_metrics_nl_dump(struct sk_buff *skb,
+                               struct netlink_callback *cb)
+{
+        struct net *net = sock_net(skb->sk);
+        unsigned int max_rows = 1U << net->ipv4.tcp_metrics_hash_log;
+        unsigned int row, s_row = cb->args[0];
+        int s_col = cb->args[1], col = s_col;
+        for (row = s_row; row < max_rows; row++, s_col = 0) {
+                struct tcp_metrics_block *tm;
+                struct tcpm_hash_bucket *hb = net->ipv4.tcp_metrics_hash + row;
+                rcu_read_lock();
+                for (col = 0, tm = rcu_dereference(hb->chain); tm;
+                     tm = rcu_dereference(tm->tcpm_next), col++) {
+                        if (col < s_col)
+                                continue;
+                        if (tcp_metrics_dump_info(skb, cb, tm) < 0) {
+                                rcu_read_unlock();
+                                goto done;
+                        }
+                }
+                rcu_read_unlock();
+        }
+done:
+        cb->args[0] = row;
+        cb->args[1] = col;
+        return skb->len;
+}
+static int parse_nl_addr(struct genl_info *info, struct inetpeer_addr *addr,
+                         unsigned int *hash, int optional)
+{
+        struct nlattr *a;
+        a = info->attrs[TCP_METRICS_ATTR_ADDR_IPV4];
+        if (a) {
+                addr->family = AF_INET;
+                addr->addr.a4 = nla_get_be32(a);
+                *hash = (__force unsigned int) addr->addr.a4;
+                return 0;
+        }
+        a = info->attrs[TCP_METRICS_ATTR_ADDR_IPV6];
+        if (a) {
+                if (nla_len(a) != sizeof(sizeof(struct in6_addr)))
+                        return -EINVAL;
+                addr->family = AF_INET6;
+                memcpy(addr->addr.a6, nla_data(a), sizeof(addr->addr.a6));
+                *hash = ipv6_addr_hash((struct in6_addr *) addr->addr.a6);
+                return 0;
+        }
+        return optional ? 1 : -EAFNOSUPPORT;
+}
+static int tcp_metrics_nl_cmd_get(struct sk_buff *skb, struct genl_info *info)
+{
+        struct tcp_metrics_block *tm;
+        struct inetpeer_addr addr;
+        unsigned int hash;
+        struct sk_buff *msg;
+        struct net *net = genl_info_net(info);
+        void *reply;
+        int ret;
+        ret = parse_nl_addr(info, &addr, &hash, 0);
+        if (ret < 0)
+                return ret;
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return -ENOMEM;
+        reply = genlmsg_put_reply(msg, info, &tcp_metrics_nl_family, 0,
+                                  info->genlhdr->cmd);
+        if (!reply)
+                goto nla_put_failure;
+        hash = hash_32(hash, net->ipv4.tcp_metrics_hash_log);
+        ret = -ESRCH;
+        rcu_read_lock();
+        for (tm = rcu_dereference(net->ipv4.tcp_metrics_hash[hash].chain); tm;
+             tm = rcu_dereference(tm->tcpm_next)) {
+                if (addr_same(&tm->tcpm_addr, &addr)) {
+                        ret = tcp_metrics_fill_info(msg, tm);
+                        break;
+                }
+        }
+        rcu_read_unlock();
+        if (ret < 0)
+                goto out_free;
+        genlmsg_end(msg, reply);
+        return genlmsg_reply(msg, info);
+nla_put_failure:
+        ret = -EMSGSIZE;
+out_free:
+        nlmsg_free(msg);
+        return ret;
+}
+#define deref_locked_genl(p)    \
+        rcu_dereference_protected(p, lockdep_genl_is_held() && \
+                                     lockdep_is_held(&tcp_metrics_lock))
+#define deref_genl(p)   rcu_dereference_protected(p, lockdep_genl_is_held())
+static int tcp_metrics_flush_all(struct net *net)
+{
+        unsigned int max_rows = 1U << net->ipv4.tcp_metrics_hash_log;
+        struct tcpm_hash_bucket *hb = net->ipv4.tcp_metrics_hash;
+        struct tcp_metrics_block *tm;
+        unsigned int row;
+        for (row = 0; row < max_rows; row++, hb++) {
+                spin_lock_bh(&tcp_metrics_lock);
+                tm = deref_locked_genl(hb->chain);
+                if (tm)
+                        hb->chain = NULL;
+                spin_unlock_bh(&tcp_metrics_lock);
+                while (tm) {
+                        struct tcp_metrics_block *next;
+                        next = deref_genl(tm->tcpm_next);
+                        kfree_rcu(tm, rcu_head);
+                        tm = next;
+                }
+        }
+        return 0;
+}
+static int tcp_metrics_nl_cmd_del(struct sk_buff *skb, struct genl_info *info)
+{
+        struct tcpm_hash_bucket *hb;
+        struct tcp_metrics_block *tm;
+        struct tcp_metrics_block __rcu **pp;
+        struct inetpeer_addr addr;
+        unsigned int hash;
+        struct net *net = genl_info_net(info);
+        int ret;
+        ret = parse_nl_addr(info, &addr, &hash, 1);
+        if (ret < 0)
+                return ret;
+        if (ret > 0)
+                return tcp_metrics_flush_all(net);
+        hash = hash_32(hash, net->ipv4.tcp_metrics_hash_log);
+        hb = net->ipv4.tcp_metrics_hash + hash;
+        pp = &hb->chain;
+        spin_lock_bh(&tcp_metrics_lock);
+        for (tm = deref_locked_genl(*pp); tm;
+             pp = &tm->tcpm_next, tm = deref_locked_genl(*pp)) {
+                if (addr_same(&tm->tcpm_addr, &addr)) {
+                        *pp = tm->tcpm_next;
+                        break;
+                }
+        }
+        spin_unlock_bh(&tcp_metrics_lock);
+        if (!tm)
+                return -ESRCH;
+        kfree_rcu(tm, rcu_head);
+        return 0;
+}
+static struct genl_ops tcp_metrics_nl_ops[] = {
+        {
+                .cmd = TCP_METRICS_CMD_GET,
+                .doit = tcp_metrics_nl_cmd_get,
+                .dumpit = tcp_metrics_nl_dump,
+                .policy = tcp_metrics_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = TCP_METRICS_CMD_DEL,
+                .doit = tcp_metrics_nl_cmd_del,
+                .policy = tcp_metrics_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+};
 static unsigned int tcpmhash_entries;
 static int __init set_tcpmhash_entries(char *str)
 {
@@ -753,5 +1065,21 @@ static __net_initdata struct pernet_operations tcp_net_metrics_ops = {
 void __init tcp_metrics_init(void)
 {
-        register_pernet_subsys(&tcp_net_metrics_ops);
+        int ret;
+        ret = register_pernet_subsys(&tcp_net_metrics_ops);
+        if (ret < 0)
+                goto cleanup;
+        ret = genl_register_family_with_ops(&tcp_metrics_nl_family,
+                                            tcp_metrics_nl_ops,
+                                            ARRAY_SIZE(tcp_metrics_nl_ops));
+        if (ret < 0)
+                goto cleanup_subsys;
+        return;
+cleanup_subsys:
+        unregister_pernet_subsys(&tcp_net_metrics_ops);
+cleanup:
+        return;
 }
author	Julian Anastasov <ja@ssi.bg>	2012-09-04 07:03:15 -0400
committer	David S. Miller <davem@davemloft.net>	2012-09-05 15:15:02 -0400
commit	d23ff701643a4a725e2c7a8ba2d567d39daa29ea (patch)
tree	039dbda9d59c1e18df6a89f600226924d452fbed /net/ipv4/tcp_metrics.c
parent	ab868256f8d6095e7200d928fcc054b66d0f13a3 (diff)

diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c index 0abe67bb4d3a..988edb63ee73 100644 --- a/net/ipv4/tcp_metrics.c +++ b/net/ipv4/tcp_metrics.c
@@ -8,6 +8,7 @@
8	#include <linux/init.h>	8	#include <linux/init.h>
9	#include <linux/tcp.h>	9	#include <linux/tcp.h>
10	#include <linux/hash.h>	10	#include <linux/hash.h>
		11	#include <linux/tcp_metrics.h>
11		12
12	#include <net/inet_connection_sock.h>	13	#include <net/inet_connection_sock.h>
13	#include <net/net_namespace.h>	14	#include <net/net_namespace.h>
@@ -17,20 +18,10 @@
17	#include <net/ipv6.h>	18	#include <net/ipv6.h>
18	#include <net/dst.h>	19	#include <net/dst.h>
19	#include <net/tcp.h>	20	#include <net/tcp.h>
		21	#include <net/genetlink.h>
20		22
21	int sysctl_tcp_nometrics_save __read_mostly;	23	int sysctl_tcp_nometrics_save __read_mostly;
22		24
23	enum tcp_metric_index {
24	TCP_METRIC_RTT,
25	TCP_METRIC_RTTVAR,
26	TCP_METRIC_SSTHRESH,
27	TCP_METRIC_CWND,
28	TCP_METRIC_REORDERING,
29
30	/* Always last. */
31	TCP_METRIC_MAX,
32	};
33
34	struct tcp_fastopen_metrics {	25	struct tcp_fastopen_metrics {
35	u16 mss;	26	u16 mss;
36	u16 syn_loss:10; /* Recurring Fast Open SYN losses */	27	u16 syn_loss:10; /* Recurring Fast Open SYN losses */
@@ -45,8 +36,10 @@ struct tcp_metrics_block {
45	u32 tcpm_ts;	36	u32 tcpm_ts;
46	u32 tcpm_ts_stamp;	37	u32 tcpm_ts_stamp;
47	u32 tcpm_lock;	38	u32 tcpm_lock;
48	u32 tcpm_vals[TCP_METRIC_MAX];	39	u32 tcpm_vals[TCP_METRIC_MAX + 1];
49	struct tcp_fastopen_metrics tcpm_fastopen;	40	struct tcp_fastopen_metrics tcpm_fastopen;
		41
		42	struct rcu_head rcu_head;
50	};	43	};
51		44
52	static bool tcp_metric_locked(struct tcp_metrics_block *tm,	45	static bool tcp_metric_locked(struct tcp_metrics_block *tm,
@@ -690,6 +683,325 @@ void tcp_fastopen_cache_set(struct sock *sk, u16 mss,
690	rcu_read_unlock();	683	rcu_read_unlock();
691	}	684	}
692		685
		686	static struct genl_family tcp_metrics_nl_family = {
		687	.id = GENL_ID_GENERATE,
		688	.hdrsize = 0,
		689	.name = TCP_METRICS_GENL_NAME,
		690	.version = TCP_METRICS_GENL_VERSION,
		691	.maxattr = TCP_METRICS_ATTR_MAX,
		692	.netnsok = true,
		693	};
		694
		695	static struct nla_policy tcp_metrics_nl_policy[TCP_METRICS_ATTR_MAX + 1] = {
		696	[TCP_METRICS_ATTR_ADDR_IPV4] = { .type = NLA_U32, },
		697	[TCP_METRICS_ATTR_ADDR_IPV6] = { .type = NLA_BINARY,
		698	.len = sizeof(struct in6_addr), },
		699	/* Following attributes are not received for GET/DEL,
		700	* we keep them for reference
		701	*/
		702	#if 0
		703	[TCP_METRICS_ATTR_AGE] = { .type = NLA_MSECS, },
		704	[TCP_METRICS_ATTR_TW_TSVAL] = { .type = NLA_U32, },
		705	[TCP_METRICS_ATTR_TW_TS_STAMP] = { .type = NLA_S32, },
		706	[TCP_METRICS_ATTR_VALS] = { .type = NLA_NESTED, },
		707	[TCP_METRICS_ATTR_FOPEN_MSS] = { .type = NLA_U16, },
		708	[TCP_METRICS_ATTR_FOPEN_SYN_DROPS] = { .type = NLA_U16, },
		709	[TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS] = { .type = NLA_MSECS, },
		710	[TCP_METRICS_ATTR_FOPEN_COOKIE] = { .type = NLA_BINARY,
		711	.len = TCP_FASTOPEN_COOKIE_MAX, },
		712	#endif
		713	};
		714
		715	/* Add attributes, caller cancels its header on failure */
		716	static int tcp_metrics_fill_info(struct sk_buff *msg,
		717	struct tcp_metrics_block *tm)
		718	{
		719	struct nlattr *nest;
		720	int i;
		721
		722	switch (tm->tcpm_addr.family) {
		723	case AF_INET:
		724	if (nla_put_be32(msg, TCP_METRICS_ATTR_ADDR_IPV4,
		725	tm->tcpm_addr.addr.a4) < 0)
		726	goto nla_put_failure;
		727	break;
		728	case AF_INET6:
		729	if (nla_put(msg, TCP_METRICS_ATTR_ADDR_IPV6, 16,
		730	tm->tcpm_addr.addr.a6) < 0)
		731	goto nla_put_failure;
		732	break;
		733	default:
		734	return -EAFNOSUPPORT;
		735	}
		736
		737	if (nla_put_msecs(msg, TCP_METRICS_ATTR_AGE,
		738	jiffies - tm->tcpm_stamp) < 0)
		739	goto nla_put_failure;
		740	if (tm->tcpm_ts_stamp) {
		741	if (nla_put_s32(msg, TCP_METRICS_ATTR_TW_TS_STAMP,
		742	(s32) (get_seconds() - tm->tcpm_ts_stamp)) < 0)
		743	goto nla_put_failure;
		744	if (nla_put_u32(msg, TCP_METRICS_ATTR_TW_TSVAL,
		745	tm->tcpm_ts) < 0)
		746	goto nla_put_failure;
		747	}
		748
		749	{
		750	int n = 0;
		751
		752	nest = nla_nest_start(msg, TCP_METRICS_ATTR_VALS);
		753	if (!nest)
		754	goto nla_put_failure;
		755	for (i = 0; i < TCP_METRIC_MAX + 1; i++) {
		756	if (!tm->tcpm_vals[i])
		757	continue;
		758	if (nla_put_u32(msg, i + 1, tm->tcpm_vals[i]) < 0)
		759	goto nla_put_failure;
		760	n++;
		761	}
		762	if (n)
		763	nla_nest_end(msg, nest);
		764	else
		765	nla_nest_cancel(msg, nest);
		766	}
		767
		768	{
		769	struct tcp_fastopen_metrics tfom_copy[1], *tfom;
		770	unsigned int seq;
		771
		772	do {
		773	seq = read_seqbegin(&fastopen_seqlock);
		774	tfom_copy[0] = tm->tcpm_fastopen;
		775	} while (read_seqretry(&fastopen_seqlock, seq));
		776
		777	tfom = tfom_copy;
		778	if (tfom->mss &&
		779	nla_put_u16(msg, TCP_METRICS_ATTR_FOPEN_MSS,
		780	tfom->mss) < 0)
		781	goto nla_put_failure;
		782	if (tfom->syn_loss &&
		783	(nla_put_u16(msg, TCP_METRICS_ATTR_FOPEN_SYN_DROPS,
		784	tfom->syn_loss) < 0 \|\|
		785	nla_put_msecs(msg, TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS,
		786	jiffies - tfom->last_syn_loss) < 0))
		787	goto nla_put_failure;
		788	if (tfom->cookie.len > 0 &&
		789	nla_put(msg, TCP_METRICS_ATTR_FOPEN_COOKIE,
		790	tfom->cookie.len, tfom->cookie.val) < 0)
		791	goto nla_put_failure;
		792	}
		793
		794	return 0;
		795
		796	nla_put_failure:
		797	return -EMSGSIZE;
		798	}
		799
		800	static int tcp_metrics_dump_info(struct sk_buff *skb,
		801	struct netlink_callback *cb,
		802	struct tcp_metrics_block *tm)
		803	{
		804	void *hdr;
		805
		806	hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
		807	&tcp_metrics_nl_family, NLM_F_MULTI,
		808	TCP_METRICS_CMD_GET);
		809	if (!hdr)
		810	return -EMSGSIZE;
		811
		812	if (tcp_metrics_fill_info(skb, tm) < 0)
		813	goto nla_put_failure;
		814
		815	return genlmsg_end(skb, hdr);
		816
		817	nla_put_failure:
		818	genlmsg_cancel(skb, hdr);
		819	return -EMSGSIZE;
		820	}
		821
		822	static int tcp_metrics_nl_dump(struct sk_buff *skb,
		823	struct netlink_callback *cb)
		824	{
		825	struct net *net = sock_net(skb->sk);
		826	unsigned int max_rows = 1U << net->ipv4.tcp_metrics_hash_log;
		827	unsigned int row, s_row = cb->args[0];
		828	int s_col = cb->args[1], col = s_col;
		829
		830	for (row = s_row; row < max_rows; row++, s_col = 0) {
		831	struct tcp_metrics_block *tm;
		832	struct tcpm_hash_bucket *hb = net->ipv4.tcp_metrics_hash + row;
		833
		834	rcu_read_lock();
		835	for (col = 0, tm = rcu_dereference(hb->chain); tm;
		836	tm = rcu_dereference(tm->tcpm_next), col++) {
		837	if (col < s_col)
		838	continue;
		839	if (tcp_metrics_dump_info(skb, cb, tm) < 0) {
		840	rcu_read_unlock();
		841	goto done;
		842	}
		843	}
		844	rcu_read_unlock();
		845	}
		846
		847	done:
		848	cb->args[0] = row;
		849	cb->args[1] = col;
		850	return skb->len;
		851	}
		852
		853	static int parse_nl_addr(struct genl_info info, struct inetpeer_addr addr,
		854	unsigned int *hash, int optional)
		855	{
		856	struct nlattr *a;
		857
		858	a = info->attrs[TCP_METRICS_ATTR_ADDR_IPV4];
		859	if (a) {
		860	addr->family = AF_INET;
		861	addr->addr.a4 = nla_get_be32(a);
		862	*hash = (__force unsigned int) addr->addr.a4;
		863	return 0;
		864	}
		865	a = info->attrs[TCP_METRICS_ATTR_ADDR_IPV6];
		866	if (a) {
		867	if (nla_len(a) != sizeof(sizeof(struct in6_addr)))
		868	return -EINVAL;
		869	addr->family = AF_INET6;
		870	memcpy(addr->addr.a6, nla_data(a), sizeof(addr->addr.a6));
		871	hash = ipv6_addr_hash((struct in6_addr ) addr->addr.a6);
		872	return 0;
		873	}
		874	return optional ? 1 : -EAFNOSUPPORT;
		875	}
		876
		877	static int tcp_metrics_nl_cmd_get(struct sk_buff skb, struct genl_info info)
		878	{
		879	struct tcp_metrics_block *tm;
		880	struct inetpeer_addr addr;
		881	unsigned int hash;
		882	struct sk_buff *msg;
		883	struct net *net = genl_info_net(info);
		884	void *reply;
		885	int ret;
		886
		887	ret = parse_nl_addr(info, &addr, &hash, 0);
		888	if (ret < 0)
		889	return ret;
		890
		891	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
		892	if (!msg)
		893	return -ENOMEM;
		894
		895	reply = genlmsg_put_reply(msg, info, &tcp_metrics_nl_family, 0,
		896	info->genlhdr->cmd);
		897	if (!reply)
		898	goto nla_put_failure;
		899
		900	hash = hash_32(hash, net->ipv4.tcp_metrics_hash_log);
		901	ret = -ESRCH;
		902	rcu_read_lock();
		903	for (tm = rcu_dereference(net->ipv4.tcp_metrics_hash[hash].chain); tm;
		904	tm = rcu_dereference(tm->tcpm_next)) {
		905	if (addr_same(&tm->tcpm_addr, &addr)) {
		906	ret = tcp_metrics_fill_info(msg, tm);
		907	break;
		908	}
		909	}
		910	rcu_read_unlock();
		911	if (ret < 0)
		912	goto out_free;
		913
		914	genlmsg_end(msg, reply);
		915	return genlmsg_reply(msg, info);
		916
		917	nla_put_failure:
		918	ret = -EMSGSIZE;
		919
		920	out_free:
		921	nlmsg_free(msg);
		922	return ret;
		923	}
		924
		925	#define deref_locked_genl(p) \
		926	rcu_dereference_protected(p, lockdep_genl_is_held() && \
		927	lockdep_is_held(&tcp_metrics_lock))
		928
		929	#define deref_genl(p) rcu_dereference_protected(p, lockdep_genl_is_held())
		930
		931	static int tcp_metrics_flush_all(struct net *net)
		932	{
		933	unsigned int max_rows = 1U << net->ipv4.tcp_metrics_hash_log;
		934	struct tcpm_hash_bucket *hb = net->ipv4.tcp_metrics_hash;
		935	struct tcp_metrics_block *tm;
		936	unsigned int row;
		937
		938	for (row = 0; row < max_rows; row++, hb++) {
		939	spin_lock_bh(&tcp_metrics_lock);
		940	tm = deref_locked_genl(hb->chain);
		941	if (tm)
		942	hb->chain = NULL;
		943	spin_unlock_bh(&tcp_metrics_lock);
		944	while (tm) {
		945	struct tcp_metrics_block *next;
		946
		947	next = deref_genl(tm->tcpm_next);
		948	kfree_rcu(tm, rcu_head);
		949	tm = next;
		950	}
		951	}
		952	return 0;
		953	}
		954
		955	static int tcp_metrics_nl_cmd_del(struct sk_buff skb, struct genl_info info)
		956	{
		957	struct tcpm_hash_bucket *hb;
		958	struct tcp_metrics_block *tm;
		959	struct tcp_metrics_block __rcu **pp;
		960	struct inetpeer_addr addr;
		961	unsigned int hash;
		962	struct net *net = genl_info_net(info);
		963	int ret;
		964
		965	ret = parse_nl_addr(info, &addr, &hash, 1);
		966	if (ret < 0)
		967	return ret;
		968	if (ret > 0)
		969	return tcp_metrics_flush_all(net);
		970
		971	hash = hash_32(hash, net->ipv4.tcp_metrics_hash_log);
		972	hb = net->ipv4.tcp_metrics_hash + hash;
		973	pp = &hb->chain;
		974	spin_lock_bh(&tcp_metrics_lock);
		975	for (tm = deref_locked_genl(*pp); tm;
		976	pp = &tm->tcpm_next, tm = deref_locked_genl(*pp)) {
		977	if (addr_same(&tm->tcpm_addr, &addr)) {
		978	*pp = tm->tcpm_next;
		979	break;
		980	}
		981	}
		982	spin_unlock_bh(&tcp_metrics_lock);
		983	if (!tm)
		984	return -ESRCH;
		985	kfree_rcu(tm, rcu_head);
		986	return 0;
		987	}
		988
		989	static struct genl_ops tcp_metrics_nl_ops[] = {
		990	{
		991	.cmd = TCP_METRICS_CMD_GET,
		992	.doit = tcp_metrics_nl_cmd_get,
		993	.dumpit = tcp_metrics_nl_dump,
		994	.policy = tcp_metrics_nl_policy,
		995	.flags = GENL_ADMIN_PERM,
		996	},
		997	{
		998	.cmd = TCP_METRICS_CMD_DEL,
		999	.doit = tcp_metrics_nl_cmd_del,
		1000	.policy = tcp_metrics_nl_policy,
		1001	.flags = GENL_ADMIN_PERM,
		1002	},
		1003	};
		1004
693	static unsigned int tcpmhash_entries;	1005	static unsigned int tcpmhash_entries;
694	static int __init set_tcpmhash_entries(char *str)	1006	static int __init set_tcpmhash_entries(char *str)
695	{	1007	{
@@ -753,5 +1065,21 @@ static __net_initdata struct pernet_operations tcp_net_metrics_ops = {
753		1065
754	void __init tcp_metrics_init(void)	1066	void __init tcp_metrics_init(void)
755	{	1067	{
756	register_pernet_subsys(&tcp_net_metrics_ops);	1068	int ret;
		1069
		1070	ret = register_pernet_subsys(&tcp_net_metrics_ops);
		1071	if (ret < 0)
		1072	goto cleanup;
		1073	ret = genl_register_family_with_ops(&tcp_metrics_nl_family,
		1074	tcp_metrics_nl_ops,
		1075	ARRAY_SIZE(tcp_metrics_nl_ops));
		1076	if (ret < 0)
		1077	goto cleanup_subsys;
		1078	return;
		1079
		1080	cleanup_subsys:
		1081	unregister_pernet_subsys(&tcp_net_metrics_ops);
		1082
		1083	cleanup:
		1084	return;
757	}	1085	}