netfilter: xt_hashlimit: netns support
[linux-2.6.git] / net / netfilter / xt_hashlimit.c
index bd45f9d..fb7fcb7 100644 (file)
@@ -1,9 +1,9 @@
-/* iptables match extension to limit the number of packets per second
- * seperately for each hashbucket (sourceip/sourceport/dstip/dstport)
+/*
+ *     xt_hashlimit - Netfilter module to limit the number of packets per time
+ *     seperately for each hashbucket (sourceip/sourceport/dstip/dstport)
  *
- * (C) 2003-2004 by Harald Welte <laforge@netfilter.org>
- *
- * $Id: ipt_hashlimit.c 3244 2004-10-20 16:24:29Z laforge@netfilter.org $
+ *     (C) 2003-2004 by Harald Welte <laforge@netfilter.org>
+ *     Copyright © CC Computer Consultants GmbH, 2007 - 2008
  *
  * Development of this code was funded by Astaro AG, http://www.astaro.com/
  */
 #include <linux/mm.h>
 #include <linux/in.h>
 #include <linux/ip.h>
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
 #include <linux/ipv6.h>
+#include <net/ipv6.h>
+#endif
+
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
 
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
-MODULE_DESCRIPTION("iptables match for limiting per hash-bucket");
+MODULE_AUTHOR("Jan Engelhardt <jengelh@computergmbh.de>");
+MODULE_DESCRIPTION("Xtables: per hash-bucket rate-limit match");
 MODULE_ALIAS("ipt_hashlimit");
 MODULE_ALIAS("ip6t_hashlimit");
 
+struct hashlimit_net {
+       struct hlist_head       htables;
+       struct proc_dir_entry   *ipt_hashlimit;
+       struct proc_dir_entry   *ip6t_hashlimit;
+};
+
+static int hashlimit_net_id;
+static inline struct hashlimit_net *hashlimit_pernet(struct net *net)
+{
+       return net_generic(net, hashlimit_net_id);
+}
+
 /* need to declare this at the top */
-static struct proc_dir_entry *hashlimit_procdir4;
-static struct proc_dir_entry *hashlimit_procdir6;
 static const struct file_operations dl_file_ops;
 
 /* hash table crap */
@@ -46,11 +63,13 @@ struct dsthash_dst {
                        __be32 src;
                        __be32 dst;
                } ip;
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
                struct {
                        __be32 src[4];
                        __be32 dst[4];
                } ip6;
-       } addr;
+#endif
+       };
        __be16 src_port;
        __be16 dst_port;
 };
@@ -72,26 +91,26 @@ struct dsthash_ent {
 struct xt_hashlimit_htable {
        struct hlist_node node;         /* global list of all htables */
        atomic_t use;
-       int family;
+       u_int8_t family;
+       bool rnd_initialized;
 
-       struct hashlimit_cfg cfg;       /* config */
+       struct hashlimit_cfg1 cfg;      /* config */
 
        /* used internally */
        spinlock_t lock;                /* lock for list_head */
        u_int32_t rnd;                  /* random seed for hash */
-       int rnd_initialized;
        unsigned int count;             /* number entries in table */
        struct timer_list timer;        /* timer for gc */
 
        /* seq_file stuff */
        struct proc_dir_entry *pde;
+       struct net *net;
 
        struct hlist_head hash[0];      /* hashtable itself */
 };
 
 static DEFINE_SPINLOCK(hashlimit_lock);        /* protects htables list */
 static DEFINE_MUTEX(hlimit_mutex);     /* additional checkentry protection */
-static HLIST_HEAD(hashlimit_htables);
 static struct kmem_cache *hashlimit_cachep __read_mostly;
 
 static inline bool dst_cmp(const struct dsthash_ent *ent,
@@ -103,7 +122,16 @@ static inline bool dst_cmp(const struct dsthash_ent *ent,
 static u_int32_t
 hash_dst(const struct xt_hashlimit_htable *ht, const struct dsthash_dst *dst)
 {
-       return jhash(dst, sizeof(*dst), ht->rnd) % ht->cfg.size;
+       u_int32_t hash = jhash2((const u32 *)dst,
+                               sizeof(*dst)/sizeof(u32),
+                               ht->rnd);
+       /*
+        * Instead of returning hash % ht->cfg.size (implying a divide)
+        * we return the high 32 bits of the (hash * ht->cfg.size) that will
+        * give results between [0 and cfg.size-1] and same hash distribution,
+        * but using a multiply, less expensive than a divide
+        */
+       return ((u64)hash * ht->cfg.size) >> 32;
 }
 
 static struct dsthash_ent *
@@ -132,8 +160,8 @@ dsthash_alloc_init(struct xt_hashlimit_htable *ht,
        /* initialize hash with random val at the time we allocate
         * the first hashtable entry */
        if (!ht->rnd_initialized) {
-               get_random_bytes(&ht->rnd, 4);
-               ht->rnd_initialized = 1;
+               get_random_bytes(&ht->rnd, sizeof(ht->rnd));
+               ht->rnd_initialized = true;
        }
 
        if (ht->cfg.max && ht->count >= ht->cfg.max) {
@@ -168,8 +196,9 @@ dsthash_free(struct xt_hashlimit_htable *ht, struct dsthash_ent *ent)
 }
 static void htable_gc(unsigned long htlong);
 
-static int htable_create(struct xt_hashlimit_info *minfo, int family)
+static int htable_create_v0(struct net *net, struct xt_hashlimit_info *minfo, u_int8_t family)
 {
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
        struct xt_hashlimit_htable *hinfo;
        unsigned int size;
        unsigned int i;
@@ -177,9 +206,9 @@ static int htable_create(struct xt_hashlimit_info *minfo, int family)
        if (minfo->cfg.size)
                size = minfo->cfg.size;
        else {
-               size = ((num_physpages << PAGE_SHIFT) / 16384) /
+               size = ((totalram_pages << PAGE_SHIFT) / 16384) /
                       sizeof(struct list_head);
-               if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))
+               if (totalram_pages > (1024 * 1024 * 1024 / PAGE_SIZE))
                        size = 8192;
                if (size < 16)
                        size = 16;
@@ -194,7 +223,18 @@ static int htable_create(struct xt_hashlimit_info *minfo, int family)
        minfo->hinfo = hinfo;
 
        /* copy match config into hashtable config */
-       memcpy(&hinfo->cfg, &minfo->cfg, sizeof(hinfo->cfg));
+       hinfo->cfg.mode        = minfo->cfg.mode;
+       hinfo->cfg.avg         = minfo->cfg.avg;
+       hinfo->cfg.burst       = minfo->cfg.burst;
+       hinfo->cfg.max         = minfo->cfg.max;
+       hinfo->cfg.gc_interval = minfo->cfg.gc_interval;
+       hinfo->cfg.expire      = minfo->cfg.expire;
+
+       if (family == NFPROTO_IPV4)
+               hinfo->cfg.srcmask = hinfo->cfg.dstmask = 32;
+       else
+               hinfo->cfg.srcmask = hinfo->cfg.dstmask = 128;
+
        hinfo->cfg.size = size;
        if (!hinfo->cfg.max)
                hinfo->cfg.max = 8 * hinfo->cfg.size;
@@ -207,24 +247,89 @@ static int htable_create(struct xt_hashlimit_info *minfo, int family)
        atomic_set(&hinfo->use, 1);
        hinfo->count = 0;
        hinfo->family = family;
-       hinfo->rnd_initialized = 0;
+       hinfo->rnd_initialized = false;
        spin_lock_init(&hinfo->lock);
-       hinfo->pde = create_proc_entry(minfo->name, 0,
-                                      family == AF_INET ? hashlimit_procdir4 :
-                                                          hashlimit_procdir6);
+       hinfo->pde = proc_create_data(minfo->name, 0,
+               (family == NFPROTO_IPV4) ?
+               hashlimit_net->ipt_hashlimit : hashlimit_net->ip6t_hashlimit,
+               &dl_file_ops, hinfo);
        if (!hinfo->pde) {
                vfree(hinfo);
                return -1;
        }
-       hinfo->pde->proc_fops = &dl_file_ops;
-       hinfo->pde->data = hinfo;
+       hinfo->net = net;
 
        setup_timer(&hinfo->timer, htable_gc, (unsigned long )hinfo);
        hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval);
        add_timer(&hinfo->timer);
 
        spin_lock_bh(&hashlimit_lock);
-       hlist_add_head(&hinfo->node, &hashlimit_htables);
+       hlist_add_head(&hinfo->node, &hashlimit_net->htables);
+       spin_unlock_bh(&hashlimit_lock);
+
+       return 0;
+}
+
+static int htable_create(struct net *net, struct xt_hashlimit_mtinfo1 *minfo,
+                        u_int8_t family)
+{
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
+       struct xt_hashlimit_htable *hinfo;
+       unsigned int size;
+       unsigned int i;
+
+       if (minfo->cfg.size) {
+               size = minfo->cfg.size;
+       } else {
+               size = (totalram_pages << PAGE_SHIFT) / 16384 /
+                      sizeof(struct list_head);
+               if (totalram_pages > 1024 * 1024 * 1024 / PAGE_SIZE)
+                       size = 8192;
+               if (size < 16)
+                       size = 16;
+       }
+       /* FIXME: don't use vmalloc() here or anywhere else -HW */
+       hinfo = vmalloc(sizeof(struct xt_hashlimit_htable) +
+                       sizeof(struct list_head) * size);
+       if (hinfo == NULL) {
+               printk(KERN_ERR "xt_hashlimit: unable to create hashtable\n");
+               return -1;
+       }
+       minfo->hinfo = hinfo;
+
+       /* copy match config into hashtable config */
+       memcpy(&hinfo->cfg, &minfo->cfg, sizeof(hinfo->cfg));
+       hinfo->cfg.size = size;
+       if (hinfo->cfg.max == 0)
+               hinfo->cfg.max = 8 * hinfo->cfg.size;
+       else if (hinfo->cfg.max < hinfo->cfg.size)
+               hinfo->cfg.max = hinfo->cfg.size;
+
+       for (i = 0; i < hinfo->cfg.size; i++)
+               INIT_HLIST_HEAD(&hinfo->hash[i]);
+
+       atomic_set(&hinfo->use, 1);
+       hinfo->count = 0;
+       hinfo->family = family;
+       hinfo->rnd_initialized = false;
+       spin_lock_init(&hinfo->lock);
+
+       hinfo->pde = proc_create_data(minfo->name, 0,
+               (family == NFPROTO_IPV4) ?
+               hashlimit_net->ipt_hashlimit : hashlimit_net->ip6t_hashlimit,
+               &dl_file_ops, hinfo);
+       if (hinfo->pde == NULL) {
+               vfree(hinfo);
+               return -1;
+       }
+       hinfo->net = net;
+
+       setup_timer(&hinfo->timer, htable_gc, (unsigned long)hinfo);
+       hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval);
+       add_timer(&hinfo->timer);
+
+       spin_lock_bh(&hashlimit_lock);
+       hlist_add_head(&hinfo->node, &hashlimit_net->htables);
        spin_unlock_bh(&hashlimit_lock);
 
        return 0;
@@ -239,7 +344,7 @@ static bool select_all(const struct xt_hashlimit_htable *ht,
 static bool select_gc(const struct xt_hashlimit_htable *ht,
                      const struct dsthash_ent *he)
 {
-       return jiffies >= he->expires;
+       return time_after_eq(jiffies, he->expires);
 }
 
 static void htable_selective_cleanup(struct xt_hashlimit_htable *ht,
@@ -275,26 +380,30 @@ static void htable_gc(unsigned long htlong)
 
 static void htable_destroy(struct xt_hashlimit_htable *hinfo)
 {
-       /* remove timer, if it is pending */
-       if (timer_pending(&hinfo->timer))
-               del_timer(&hinfo->timer);
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(hinfo->net);
+       struct proc_dir_entry *parent;
 
-       /* remove proc entry */
-       remove_proc_entry(hinfo->pde->name,
-                         hinfo->family == AF_INET ? hashlimit_procdir4 :
-                                                    hashlimit_procdir6);
+       del_timer_sync(&hinfo->timer);
+
+       if (hinfo->family == NFPROTO_IPV4)
+               parent = hashlimit_net->ipt_hashlimit;
+       else
+               parent = hashlimit_net->ip6t_hashlimit;
+       remove_proc_entry(hinfo->pde->name, parent);
        htable_selective_cleanup(hinfo, select_all);
        vfree(hinfo);
 }
 
-static struct xt_hashlimit_htable *htable_find_get(const char *name,
-                                                  int family)
+static struct xt_hashlimit_htable *htable_find_get(struct net *net,
+                                                  const char *name,
+                                                  u_int8_t family)
 {
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
        struct xt_hashlimit_htable *hinfo;
        struct hlist_node *pos;
 
        spin_lock_bh(&hashlimit_lock);
-       hlist_for_each_entry(hinfo, pos, &hashlimit_htables, node) {
+       hlist_for_each_entry(hinfo, pos, &hashlimit_net->htables, node) {
                if (!strcmp(name, hinfo->pde->name) &&
                    hinfo->family == family) {
                        atomic_inc(&hinfo->use);
@@ -372,22 +481,53 @@ static inline void rateinfo_recalc(struct dsthash_ent *dh, unsigned long now)
        dh->rateinfo.prev = now;
 }
 
+static inline __be32 maskl(__be32 a, unsigned int l)
+{
+       return l ? htonl(ntohl(a) & ~0 << (32 - l)) : 0;
+}
+
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+static void hashlimit_ipv6_mask(__be32 *i, unsigned int p)
+{
+       switch (p) {
+       case 0 ... 31:
+               i[0] = maskl(i[0], p);
+               i[1] = i[2] = i[3] = 0;
+               break;
+       case 32 ... 63:
+               i[1] = maskl(i[1], p - 32);
+               i[2] = i[3] = 0;
+               break;
+       case 64 ... 95:
+               i[2] = maskl(i[2], p - 64);
+               i[3] = 0;
+       case 96 ... 127:
+               i[3] = maskl(i[3], p - 96);
+               break;
+       case 128:
+               break;
+       }
+}
+#endif
+
 static int
 hashlimit_init_dst(const struct xt_hashlimit_htable *hinfo,
                   struct dsthash_dst *dst,
                   const struct sk_buff *skb, unsigned int protoff)
 {
        __be16 _ports[2], *ports;
-       int nexthdr;
+       u8 nexthdr;
 
        memset(dst, 0, sizeof(*dst));
 
        switch (hinfo->family) {
-       case AF_INET:
+       case NFPROTO_IPV4:
                if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_DIP)
-                       dst->addr.ip.dst = ip_hdr(skb)->daddr;
+                       dst->ip.dst = maskl(ip_hdr(skb)->daddr,
+                                     hinfo->cfg.dstmask);
                if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_SIP)
-                       dst->addr.ip.src = ip_hdr(skb)->saddr;
+                       dst->ip.src = maskl(ip_hdr(skb)->saddr,
+                                     hinfo->cfg.srcmask);
 
                if (!(hinfo->cfg.mode &
                      (XT_HASHLIMIT_HASH_DPT | XT_HASHLIMIT_HASH_SPT)))
@@ -395,19 +535,24 @@ hashlimit_init_dst(const struct xt_hashlimit_htable *hinfo,
                nexthdr = ip_hdr(skb)->protocol;
                break;
 #if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
-       case AF_INET6:
-               if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_DIP)
-                       memcpy(&dst->addr.ip6.dst, &ipv6_hdr(skb)->daddr,
-                              sizeof(dst->addr.ip6.dst));
-               if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_SIP)
-                       memcpy(&dst->addr.ip6.src, &ipv6_hdr(skb)->saddr,
-                              sizeof(dst->addr.ip6.src));
+       case NFPROTO_IPV6:
+               if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_DIP) {
+                       memcpy(&dst->ip6.dst, &ipv6_hdr(skb)->daddr,
+                              sizeof(dst->ip6.dst));
+                       hashlimit_ipv6_mask(dst->ip6.dst, hinfo->cfg.dstmask);
+               }
+               if (hinfo->cfg.mode & XT_HASHLIMIT_HASH_SIP) {
+                       memcpy(&dst->ip6.src, &ipv6_hdr(skb)->saddr,
+                              sizeof(dst->ip6.src));
+                       hashlimit_ipv6_mask(dst->ip6.src, hinfo->cfg.srcmask);
+               }
 
                if (!(hinfo->cfg.mode &
                      (XT_HASHLIMIT_HASH_DPT | XT_HASHLIMIT_HASH_SPT)))
                        return 0;
-               nexthdr = ipv6_find_hdr(skb, &protoff, -1, NULL);
-               if (nexthdr < 0)
+               nexthdr = ipv6_hdr(skb)->nexthdr;
+               protoff = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
+               if ((int)protoff < 0)
                        return -1;
                break;
 #endif
@@ -440,23 +585,15 @@ hashlimit_init_dst(const struct xt_hashlimit_htable *hinfo,
 }
 
 static bool
-hashlimit_match(const struct sk_buff *skb,
-               const struct net_device *in,
-               const struct net_device *out,
-               const struct xt_match *match,
-               const void *matchinfo,
-               int offset,
-               unsigned int protoff,
-               bool *hotdrop)
-{
-       const struct xt_hashlimit_info *r =
-               ((const struct xt_hashlimit_info *)matchinfo)->u.master;
+hashlimit_mt_v0(const struct sk_buff *skb, const struct xt_match_param *par)
+{
+       const struct xt_hashlimit_info *r = par->matchinfo;
        struct xt_hashlimit_htable *hinfo = r->hinfo;
        unsigned long now = jiffies;
        struct dsthash_ent *dh;
        struct dsthash_dst dst;
 
-       if (hashlimit_init_dst(hinfo, &dst, skb, protoff) < 0)
+       if (hashlimit_init_dst(hinfo, &dst, skb, par->thoff) < 0)
                goto hotdrop;
 
        spin_lock_bh(&hinfo->lock);
@@ -494,18 +631,64 @@ hashlimit_match(const struct sk_buff *skb,
        return false;
 
 hotdrop:
-       *hotdrop = true;
+       *par->hotdrop = true;
        return false;
 }
 
 static bool
-hashlimit_checkentry(const char *tablename,
-                    const void *inf,
-                    const struct xt_match *match,
-                    void *matchinfo,
-                    unsigned int hook_mask)
+hashlimit_mt(const struct sk_buff *skb, const struct xt_match_param *par)
 {
-       struct xt_hashlimit_info *r = matchinfo;
+       const struct xt_hashlimit_mtinfo1 *info = par->matchinfo;
+       struct xt_hashlimit_htable *hinfo = info->hinfo;
+       unsigned long now = jiffies;
+       struct dsthash_ent *dh;
+       struct dsthash_dst dst;
+
+       if (hashlimit_init_dst(hinfo, &dst, skb, par->thoff) < 0)
+               goto hotdrop;
+
+       spin_lock_bh(&hinfo->lock);
+       dh = dsthash_find(hinfo, &dst);
+       if (dh == NULL) {
+               dh = dsthash_alloc_init(hinfo, &dst);
+               if (dh == NULL) {
+                       spin_unlock_bh(&hinfo->lock);
+                       goto hotdrop;
+               }
+
+               dh->expires = jiffies + msecs_to_jiffies(hinfo->cfg.expire);
+               dh->rateinfo.prev = jiffies;
+               dh->rateinfo.credit = user2credits(hinfo->cfg.avg *
+                                     hinfo->cfg.burst);
+               dh->rateinfo.credit_cap = user2credits(hinfo->cfg.avg *
+                                         hinfo->cfg.burst);
+               dh->rateinfo.cost = user2credits(hinfo->cfg.avg);
+       } else {
+               /* update expiration timeout */
+               dh->expires = now + msecs_to_jiffies(hinfo->cfg.expire);
+               rateinfo_recalc(dh, now);
+       }
+
+       if (dh->rateinfo.credit >= dh->rateinfo.cost) {
+               /* below the limit */
+               dh->rateinfo.credit -= dh->rateinfo.cost;
+               spin_unlock_bh(&hinfo->lock);
+               return !(info->cfg.mode & XT_HASHLIMIT_INVERT);
+       }
+
+       spin_unlock_bh(&hinfo->lock);
+       /* default match is underlimit - so over the limit, we need to invert */
+       return info->cfg.mode & XT_HASHLIMIT_INVERT;
+
+ hotdrop:
+       *par->hotdrop = true;
+       return false;
+}
+
+static bool hashlimit_mt_check_v0(const struct xt_mtchk_param *par)
+{
+       struct net *net = par->net;
+       struct xt_hashlimit_info *r = par->matchinfo;
 
        /* Check for overflow. */
        if (r->cfg.burst == 0 ||
@@ -534,26 +717,72 @@ hashlimit_checkentry(const char *tablename,
         * the list of htable's in htable_create(), since then we would
         * create duplicate proc files. -HW */
        mutex_lock(&hlimit_mutex);
-       r->hinfo = htable_find_get(r->name, match->family);
-       if (!r->hinfo && htable_create(r, match->family) != 0) {
+       r->hinfo = htable_find_get(net, r->name, par->match->family);
+       if (!r->hinfo && htable_create_v0(net, r, par->match->family) != 0) {
                mutex_unlock(&hlimit_mutex);
                return false;
        }
        mutex_unlock(&hlimit_mutex);
 
-       /* Ugly hack: For SMP, we only want to use one set */
-       r->u.master = r;
+       return true;
+}
+
+static bool hashlimit_mt_check(const struct xt_mtchk_param *par)
+{
+       struct net *net = par->net;
+       struct xt_hashlimit_mtinfo1 *info = par->matchinfo;
+
+       /* Check for overflow. */
+       if (info->cfg.burst == 0 ||
+           user2credits(info->cfg.avg * info->cfg.burst) <
+           user2credits(info->cfg.avg)) {
+               printk(KERN_ERR "xt_hashlimit: overflow, try lower: %u/%u\n",
+                      info->cfg.avg, info->cfg.burst);
+               return false;
+       }
+       if (info->cfg.gc_interval == 0 || info->cfg.expire == 0)
+               return false;
+       if (info->name[sizeof(info->name)-1] != '\0')
+               return false;
+       if (par->match->family == NFPROTO_IPV4) {
+               if (info->cfg.srcmask > 32 || info->cfg.dstmask > 32)
+                       return false;
+       } else {
+               if (info->cfg.srcmask > 128 || info->cfg.dstmask > 128)
+                       return false;
+       }
+
+       /* This is the best we've got: We cannot release and re-grab lock,
+        * since checkentry() is called before x_tables.c grabs xt_mutex.
+        * We also cannot grab the hashtable spinlock, since htable_create will
+        * call vmalloc, and that can sleep.  And we cannot just re-search
+        * the list of htable's in htable_create(), since then we would
+        * create duplicate proc files. -HW */
+       mutex_lock(&hlimit_mutex);
+       info->hinfo = htable_find_get(net, info->name, par->match->family);
+       if (!info->hinfo && htable_create(net, info, par->match->family) != 0) {
+               mutex_unlock(&hlimit_mutex);
+               return false;
+       }
+       mutex_unlock(&hlimit_mutex);
        return true;
 }
 
 static void
-hashlimit_destroy(const struct xt_match *match, void *matchinfo)
+hashlimit_mt_destroy_v0(const struct xt_mtdtor_param *par)
 {
-       const struct xt_hashlimit_info *r = matchinfo;
+       const struct xt_hashlimit_info *r = par->matchinfo;
 
        htable_put(r->hinfo);
 }
 
+static void hashlimit_mt_destroy(const struct xt_mtdtor_param *par)
+{
+       const struct xt_hashlimit_mtinfo1 *info = par->matchinfo;
+
+       htable_put(info->hinfo);
+}
+
 #ifdef CONFIG_COMPAT
 struct compat_xt_hashlimit_info {
        char name[IFNAMSIZ];
@@ -562,7 +791,7 @@ struct compat_xt_hashlimit_info {
        compat_uptr_t master;
 };
 
-static void compat_from_user(void *dst, void *src)
+static void hashlimit_mt_compat_from_user(void *dst, void *src)
 {
        int off = offsetof(struct compat_xt_hashlimit_info, hinfo);
 
@@ -570,7 +799,7 @@ static void compat_from_user(void *dst, void *src)
        memset(dst + off, 0, sizeof(struct compat_xt_hashlimit_info) - off);
 }
 
-static int compat_to_user(void __user *dst, void *src)
+static int hashlimit_mt_compat_to_user(void __user *dst, void *src)
 {
        int off = offsetof(struct compat_xt_hashlimit_info, hinfo);
 
@@ -578,42 +807,65 @@ static int compat_to_user(void __user *dst, void *src)
 }
 #endif
 
-static struct xt_match xt_hashlimit[] __read_mostly = {
+static struct xt_match hashlimit_mt_reg[] __read_mostly = {
        {
                .name           = "hashlimit",
-               .family         = AF_INET,
-               .match          = hashlimit_match,
+               .revision       = 0,
+               .family         = NFPROTO_IPV4,
+               .match          = hashlimit_mt_v0,
                .matchsize      = sizeof(struct xt_hashlimit_info),
 #ifdef CONFIG_COMPAT
                .compatsize     = sizeof(struct compat_xt_hashlimit_info),
-               .compat_from_user = compat_from_user,
-               .compat_to_user = compat_to_user,
+               .compat_from_user = hashlimit_mt_compat_from_user,
+               .compat_to_user = hashlimit_mt_compat_to_user,
 #endif
-               .checkentry     = hashlimit_checkentry,
-               .destroy        = hashlimit_destroy,
+               .checkentry     = hashlimit_mt_check_v0,
+               .destroy        = hashlimit_mt_destroy_v0,
                .me             = THIS_MODULE
        },
        {
+               .name           = "hashlimit",
+               .revision       = 1,
+               .family         = NFPROTO_IPV4,
+               .match          = hashlimit_mt,
+               .matchsize      = sizeof(struct xt_hashlimit_mtinfo1),
+               .checkentry     = hashlimit_mt_check,
+               .destroy        = hashlimit_mt_destroy,
+               .me             = THIS_MODULE,
+       },
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+       {
                .name           = "hashlimit",
-               .family         = AF_INET6,
-               .match          = hashlimit_match,
+               .family         = NFPROTO_IPV6,
+               .match          = hashlimit_mt_v0,
                .matchsize      = sizeof(struct xt_hashlimit_info),
 #ifdef CONFIG_COMPAT
                .compatsize     = sizeof(struct compat_xt_hashlimit_info),
-               .compat_from_user = compat_from_user,
-               .compat_to_user = compat_to_user,
+               .compat_from_user = hashlimit_mt_compat_from_user,
+               .compat_to_user = hashlimit_mt_compat_to_user,
 #endif
-               .checkentry     = hashlimit_checkentry,
-               .destroy        = hashlimit_destroy,
+               .checkentry     = hashlimit_mt_check_v0,
+               .destroy        = hashlimit_mt_destroy_v0,
                .me             = THIS_MODULE
        },
+       {
+               .name           = "hashlimit",
+               .revision       = 1,
+               .family         = NFPROTO_IPV6,
+               .match          = hashlimit_mt,
+               .matchsize      = sizeof(struct xt_hashlimit_mtinfo1),
+               .checkentry     = hashlimit_mt_check,
+               .destroy        = hashlimit_mt_destroy,
+               .me             = THIS_MODULE,
+       },
+#endif
 };
 
 /* PROC stuff */
 static void *dl_seq_start(struct seq_file *s, loff_t *pos)
+       __acquires(htable->lock)
 {
-       struct proc_dir_entry *pde = s->private;
-       struct xt_hashlimit_htable *htable = pde->data;
+       struct xt_hashlimit_htable *htable = s->private;
        unsigned int *bucket;
 
        spin_lock_bh(&htable->lock);
@@ -630,8 +882,7 @@ static void *dl_seq_start(struct seq_file *s, loff_t *pos)
 
 static void *dl_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
-       struct proc_dir_entry *pde = s->private;
-       struct xt_hashlimit_htable *htable = pde->data;
+       struct xt_hashlimit_htable *htable = s->private;
        unsigned int *bucket = (unsigned int *)v;
 
        *pos = ++(*bucket);
@@ -643,42 +894,42 @@ static void *dl_seq_next(struct seq_file *s, void *v, loff_t *pos)
 }
 
 static void dl_seq_stop(struct seq_file *s, void *v)
+       __releases(htable->lock)
 {
-       struct proc_dir_entry *pde = s->private;
-       struct xt_hashlimit_htable *htable = pde->data;
+       struct xt_hashlimit_htable *htable = s->private;
        unsigned int *bucket = (unsigned int *)v;
 
        kfree(bucket);
        spin_unlock_bh(&htable->lock);
 }
 
-static int dl_seq_real_show(struct dsthash_ent *ent, int family,
+static int dl_seq_real_show(struct dsthash_ent *ent, u_int8_t family,
                                   struct seq_file *s)
 {
        /* recalculate to show accurate numbers */
        rateinfo_recalc(ent, jiffies);
 
        switch (family) {
-       case AF_INET:
-               return seq_printf(s, "%ld %u.%u.%u.%u:%u->"
-                                    "%u.%u.%u.%u:%u %u %u %u\n",
+       case NFPROTO_IPV4:
+               return seq_printf(s, "%ld %pI4:%u->%pI4:%u %u %u %u\n",
                                 (long)(ent->expires - jiffies)/HZ,
-                                NIPQUAD(ent->dst.addr.ip.src),
+                                &ent->dst.ip.src,
                                 ntohs(ent->dst.src_port),
-                                NIPQUAD(ent->dst.addr.ip.dst),
+                                &ent->dst.ip.dst,
                                 ntohs(ent->dst.dst_port),
                                 ent->rateinfo.credit, ent->rateinfo.credit_cap,
                                 ent->rateinfo.cost);
-       case AF_INET6:
-               return seq_printf(s, "%ld " NIP6_FMT ":%u->"
-                                    NIP6_FMT ":%u %u %u %u\n",
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+       case NFPROTO_IPV6:
+               return seq_printf(s, "%ld %pI6:%u->%pI6:%u %u %u %u\n",
                                 (long)(ent->expires - jiffies)/HZ,
-                                NIP6(*(struct in6_addr *)&ent->dst.addr.ip6.src),
+                                &ent->dst.ip6.src,
                                 ntohs(ent->dst.src_port),
-                                NIP6(*(struct in6_addr *)&ent->dst.addr.ip6.dst),
+                                &ent->dst.ip6.dst,
                                 ntohs(ent->dst.dst_port),
                                 ent->rateinfo.credit, ent->rateinfo.credit_cap,
                                 ent->rateinfo.cost);
+#endif
        default:
                BUG();
                return 0;
@@ -687,8 +938,7 @@ static int dl_seq_real_show(struct dsthash_ent *ent, int family,
 
 static int dl_seq_show(struct seq_file *s, void *v)
 {
-       struct proc_dir_entry *pde = s->private;
-       struct xt_hashlimit_htable *htable = pde->data;
+       struct xt_hashlimit_htable *htable = s->private;
        unsigned int *bucket = (unsigned int *)v;
        struct dsthash_ent *ent;
        struct hlist_node *pos;
@@ -696,7 +946,7 @@ static int dl_seq_show(struct seq_file *s, void *v)
        if (!hlist_empty(&htable->hash[*bucket])) {
                hlist_for_each_entry(ent, pos, &htable->hash[*bucket], node)
                        if (dl_seq_real_show(ent, htable->family, s))
-                               return 1;
+                               return -1;
        }
        return 0;
 }
@@ -714,7 +964,7 @@ static int dl_proc_open(struct inode *inode, struct file *file)
 
        if (!ret) {
                struct seq_file *sf = file->private_data;
-               sf->private = PDE(inode);
+               sf->private = PDE(inode)->data;
        }
        return ret;
 }
@@ -727,11 +977,63 @@ static const struct file_operations dl_file_ops = {
        .release = seq_release
 };
 
-static int __init xt_hashlimit_init(void)
+static int __net_init hashlimit_proc_net_init(struct net *net)
+{
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
+
+       hashlimit_net->ipt_hashlimit = proc_mkdir("ipt_hashlimit", net->proc_net);
+       if (!hashlimit_net->ipt_hashlimit)
+               return -ENOMEM;
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+       hashlimit_net->ip6t_hashlimit = proc_mkdir("ip6t_hashlimit", net->proc_net);
+       if (!hashlimit_net->ip6t_hashlimit) {
+               proc_net_remove(net, "ipt_hashlimit");
+               return -ENOMEM;
+       }
+#endif
+       return 0;
+}
+
+static void __net_exit hashlimit_proc_net_exit(struct net *net)
+{
+       proc_net_remove(net, "ipt_hashlimit");
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+       proc_net_remove(net, "ip6t_hashlimit");
+#endif
+}
+
+static int __net_init hashlimit_net_init(struct net *net)
+{
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
+
+       INIT_HLIST_HEAD(&hashlimit_net->htables);
+       return hashlimit_proc_net_init(net);
+}
+
+static void __net_exit hashlimit_net_exit(struct net *net)
+{
+       struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
+
+       BUG_ON(!hlist_empty(&hashlimit_net->htables));
+       hashlimit_proc_net_exit(net);
+}
+
+static struct pernet_operations hashlimit_net_ops = {
+       .init   = hashlimit_net_init,
+       .exit   = hashlimit_net_exit,
+       .id     = &hashlimit_net_id,
+       .size   = sizeof(struct hashlimit_net),
+};
+
+static int __init hashlimit_mt_init(void)
 {
        int err;
 
-       err = xt_register_matches(xt_hashlimit, ARRAY_SIZE(xt_hashlimit));
+       err = register_pernet_subsys(&hashlimit_net_ops);
+       if (err < 0)
+               return err;
+       err = xt_register_matches(hashlimit_mt_reg,
+             ARRAY_SIZE(hashlimit_mt_reg));
        if (err < 0)
                goto err1;
 
@@ -743,37 +1045,22 @@ static int __init xt_hashlimit_init(void)
                printk(KERN_ERR "xt_hashlimit: unable to create slab cache\n");
                goto err2;
        }
-       hashlimit_procdir4 = proc_mkdir("ipt_hashlimit", proc_net);
-       if (!hashlimit_procdir4) {
-               printk(KERN_ERR "xt_hashlimit: unable to create proc dir "
-                               "entry\n");
-               goto err3;
-       }
-       hashlimit_procdir6 = proc_mkdir("ip6t_hashlimit", proc_net);
-       if (!hashlimit_procdir6) {
-               printk(KERN_ERR "xt_hashlimit: unable to create proc dir "
-                               "entry\n");
-               goto err4;
-       }
        return 0;
-err4:
-       remove_proc_entry("ipt_hashlimit", proc_net);
-err3:
-       kmem_cache_destroy(hashlimit_cachep);
+
 err2:
-       xt_unregister_matches(xt_hashlimit, ARRAY_SIZE(xt_hashlimit));
+       xt_unregister_matches(hashlimit_mt_reg, ARRAY_SIZE(hashlimit_mt_reg));
 err1:
+       unregister_pernet_subsys(&hashlimit_net_ops);
        return err;
 
 }
 
-static void __exit xt_hashlimit_fini(void)
+static void __exit hashlimit_mt_exit(void)
 {
-       remove_proc_entry("ipt_hashlimit", proc_net);
-       remove_proc_entry("ip6t_hashlimit", proc_net);
        kmem_cache_destroy(hashlimit_cachep);
-       xt_unregister_matches(xt_hashlimit, ARRAY_SIZE(xt_hashlimit));
+       xt_unregister_matches(hashlimit_mt_reg, ARRAY_SIZE(hashlimit_mt_reg));
+       unregister_pernet_subsys(&hashlimit_net_ops);
 }
 
-module_init(xt_hashlimit_init);
-module_exit(xt_hashlimit_fini);
+module_init(hashlimit_mt_init);
+module_exit(hashlimit_mt_exit);