linux/net/netfilter/xt_recent.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2006 Patrick McHardy <kaber@trash.net>
   3 * Copyright © CC Computer Consultants GmbH, 2007 - 2008
   4 *
   5 * This program is free software; you can redistribute it and/or modify
   6 * it under the terms of the GNU General Public License version 2 as
   7 * published by the Free Software Foundation.
   8 *
   9 * This is a replacement of the old ipt_recent module, which carried the
  10 * following copyright notice:
  11 *
  12 * Author: Stephen Frost <sfrost@snowman.net>
  13 * Copyright 2002-2003, Stephen Frost, 2.5.x port by laforge@netfilter.org
  14 */
  15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16#include <linux/init.h>
  17#include <linux/ip.h>
  18#include <linux/ipv6.h>
  19#include <linux/module.h>
  20#include <linux/moduleparam.h>
  21#include <linux/proc_fs.h>
  22#include <linux/seq_file.h>
  23#include <linux/string.h>
  24#include <linux/ctype.h>
  25#include <linux/list.h>
  26#include <linux/random.h>
  27#include <linux/jhash.h>
  28#include <linux/bitops.h>
  29#include <linux/skbuff.h>
  30#include <linux/inet.h>
  31#include <linux/slab.h>
  32#include <net/net_namespace.h>
  33#include <net/netns/generic.h>
  34
  35#include <linux/netfilter/x_tables.h>
  36#include <linux/netfilter/xt_recent.h>
  37
  38MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
  39MODULE_AUTHOR("Jan Engelhardt <jengelh@medozas.de>");
  40MODULE_DESCRIPTION("Xtables: \"recently-seen\" host matching");
  41MODULE_LICENSE("GPL");
  42MODULE_ALIAS("ipt_recent");
  43MODULE_ALIAS("ip6t_recent");
  44
  45static unsigned int ip_list_tot = 100;
  46static unsigned int ip_pkt_list_tot = 20;
  47static unsigned int ip_list_hash_size = 0;
  48static unsigned int ip_list_perms = 0644;
  49static unsigned int ip_list_uid = 0;
  50static unsigned int ip_list_gid = 0;
  51module_param(ip_list_tot, uint, 0400);
  52module_param(ip_pkt_list_tot, uint, 0400);
  53module_param(ip_list_hash_size, uint, 0400);
  54module_param(ip_list_perms, uint, 0400);
  55module_param(ip_list_uid, uint, S_IRUGO | S_IWUSR);
  56module_param(ip_list_gid, uint, S_IRUGO | S_IWUSR);
  57MODULE_PARM_DESC(ip_list_tot, "number of IPs to remember per list");
  58MODULE_PARM_DESC(ip_pkt_list_tot, "number of packets per IP address to remember (max. 255)");
  59MODULE_PARM_DESC(ip_list_hash_size, "size of hash table used to look up IPs");
  60MODULE_PARM_DESC(ip_list_perms, "permissions on /proc/net/xt_recent/* files");
  61MODULE_PARM_DESC(ip_list_uid, "default owner of /proc/net/xt_recent/* files");
  62MODULE_PARM_DESC(ip_list_gid, "default owning group of /proc/net/xt_recent/* files");
  63
  64struct recent_entry {
  65        struct list_head        list;
  66        struct list_head        lru_list;
  67        union nf_inet_addr      addr;
  68        u_int16_t               family;
  69        u_int8_t                ttl;
  70        u_int8_t                index;
  71        u_int16_t               nstamps;
  72        unsigned long           stamps[0];
  73};
  74
  75struct recent_table {
  76        struct list_head        list;
  77        char                    name[XT_RECENT_NAME_LEN];
  78        unsigned int            refcnt;
  79        unsigned int            entries;
  80        struct list_head        lru_list;
  81        struct list_head        iphash[0];
  82};
  83
  84struct recent_net {
  85        struct list_head        tables;
  86#ifdef CONFIG_PROC_FS
  87        struct proc_dir_entry   *xt_recent;
  88#endif
  89};
  90
  91static int recent_net_id;
  92static inline struct recent_net *recent_pernet(struct net *net)
  93{
  94        return net_generic(net, recent_net_id);
  95}
  96
  97static DEFINE_SPINLOCK(recent_lock);
  98static DEFINE_MUTEX(recent_mutex);
  99
 100#ifdef CONFIG_PROC_FS
 101static const struct file_operations recent_old_fops, recent_mt_fops;
 102#endif
 103
 104static u_int32_t hash_rnd __read_mostly;
 105static bool hash_rnd_inited __read_mostly;
 106
 107static inline unsigned int recent_entry_hash4(const union nf_inet_addr *addr)
 108{
 109        return jhash_1word((__force u32)addr->ip, hash_rnd) &
 110               (ip_list_hash_size - 1);
 111}
 112
 113static inline unsigned int recent_entry_hash6(const union nf_inet_addr *addr)
 114{
 115        return jhash2((u32 *)addr->ip6, ARRAY_SIZE(addr->ip6), hash_rnd) &
 116               (ip_list_hash_size - 1);
 117}
 118
 119static struct recent_entry *
 120recent_entry_lookup(const struct recent_table *table,
 121                    const union nf_inet_addr *addrp, u_int16_t family,
 122                    u_int8_t ttl)
 123{
 124        struct recent_entry *e;
 125        unsigned int h;
 126
 127        if (family == NFPROTO_IPV4)
 128                h = recent_entry_hash4(addrp);
 129        else
 130                h = recent_entry_hash6(addrp);
 131
 132        list_for_each_entry(e, &table->iphash[h], list)
 133                if (e->family == family &&
 134                    memcmp(&e->addr, addrp, sizeof(e->addr)) == 0 &&
 135                    (ttl == e->ttl || ttl == 0 || e->ttl == 0))
 136                        return e;
 137        return NULL;
 138}
 139
 140static void recent_entry_remove(struct recent_table *t, struct recent_entry *e)
 141{
 142        list_del(&e->list);
 143        list_del(&e->lru_list);
 144        kfree(e);
 145        t->entries--;
 146}
 147
 148/*
 149 * Drop entries with timestamps older then 'time'.
 150 */
 151static void recent_entry_reap(struct recent_table *t, unsigned long time)
 152{
 153        struct recent_entry *e;
 154
 155        /*
 156         * The head of the LRU list is always the oldest entry.
 157         */
 158        e = list_entry(t->lru_list.next, struct recent_entry, lru_list);
 159
 160        /*
 161         * The last time stamp is the most recent.
 162         */
 163        if (time_after(time, e->stamps[e->index-1]))
 164                recent_entry_remove(t, e);
 165}
 166
 167static struct recent_entry *
 168recent_entry_init(struct recent_table *t, const union nf_inet_addr *addr,
 169                  u_int16_t family, u_int8_t ttl)
 170{
 171        struct recent_entry *e;
 172
 173        if (t->entries >= ip_list_tot) {
 174                e = list_entry(t->lru_list.next, struct recent_entry, lru_list);
 175                recent_entry_remove(t, e);
 176        }
 177        e = kmalloc(sizeof(*e) + sizeof(e->stamps[0]) * ip_pkt_list_tot,
 178                    GFP_ATOMIC);
 179        if (e == NULL)
 180                return NULL;
 181        memcpy(&e->addr, addr, sizeof(e->addr));
 182        e->ttl       = ttl;
 183        e->stamps[0] = jiffies;
 184        e->nstamps   = 1;
 185        e->index     = 1;
 186        e->family    = family;
 187        if (family == NFPROTO_IPV4)
 188                list_add_tail(&e->list, &t->iphash[recent_entry_hash4(addr)]);
 189        else
 190                list_add_tail(&e->list, &t->iphash[recent_entry_hash6(addr)]);
 191        list_add_tail(&e->lru_list, &t->lru_list);
 192        t->entries++;
 193        return e;
 194}
 195
 196static void recent_entry_update(struct recent_table *t, struct recent_entry *e)
 197{
 198        e->index %= ip_pkt_list_tot;
 199        e->stamps[e->index++] = jiffies;
 200        if (e->index > e->nstamps)
 201                e->nstamps = e->index;
 202        list_move_tail(&e->lru_list, &t->lru_list);
 203}
 204
 205static struct recent_table *recent_table_lookup(struct recent_net *recent_net,
 206                                                const char *name)
 207{
 208        struct recent_table *t;
 209
 210        list_for_each_entry(t, &recent_net->tables, list)
 211                if (!strcmp(t->name, name))
 212                        return t;
 213        return NULL;
 214}
 215
 216static void recent_table_flush(struct recent_table *t)
 217{
 218        struct recent_entry *e, *next;
 219        unsigned int i;
 220
 221        for (i = 0; i < ip_list_hash_size; i++)
 222                list_for_each_entry_safe(e, next, &t->iphash[i], list)
 223                        recent_entry_remove(t, e);
 224}
 225
 226static bool
 227recent_mt(const struct sk_buff *skb, struct xt_action_param *par)
 228{
 229        struct net *net = dev_net(par->in ? par->in : par->out);
 230        struct recent_net *recent_net = recent_pernet(net);
 231        const struct xt_recent_mtinfo *info = par->matchinfo;
 232        struct recent_table *t;
 233        struct recent_entry *e;
 234        union nf_inet_addr addr = {};
 235        u_int8_t ttl;
 236        bool ret = info->invert;
 237
 238        if (par->family == NFPROTO_IPV4) {
 239                const struct iphdr *iph = ip_hdr(skb);
 240
 241                if (info->side == XT_RECENT_DEST)
 242                        addr.ip = iph->daddr;
 243                else
 244                        addr.ip = iph->saddr;
 245
 246                ttl = iph->ttl;
 247        } else {
 248                const struct ipv6hdr *iph = ipv6_hdr(skb);
 249
 250                if (info->side == XT_RECENT_DEST)
 251                        memcpy(&addr.in6, &iph->daddr, sizeof(addr.in6));
 252                else
 253                        memcpy(&addr.in6, &iph->saddr, sizeof(addr.in6));
 254
 255                ttl = iph->hop_limit;
 256        }
 257
 258        /* use TTL as seen before forwarding */
 259        if (par->out != NULL && skb->sk == NULL)
 260                ttl++;
 261
 262        spin_lock_bh(&recent_lock);
 263        t = recent_table_lookup(recent_net, info->name);
 264        e = recent_entry_lookup(t, &addr, par->family,
 265                                (info->check_set & XT_RECENT_TTL) ? ttl : 0);
 266        if (e == NULL) {
 267                if (!(info->check_set & XT_RECENT_SET))
 268                        goto out;
 269                e = recent_entry_init(t, &addr, par->family, ttl);
 270                if (e == NULL)
 271                        par->hotdrop = true;
 272                ret = !ret;
 273                goto out;
 274        }
 275
 276        if (info->check_set & XT_RECENT_SET)
 277                ret = !ret;
 278        else if (info->check_set & XT_RECENT_REMOVE) {
 279                recent_entry_remove(t, e);
 280                ret = !ret;
 281        } else if (info->check_set & (XT_RECENT_CHECK | XT_RECENT_UPDATE)) {
 282                unsigned long time = jiffies - info->seconds * HZ;
 283                unsigned int i, hits = 0;
 284
 285                for (i = 0; i < e->nstamps; i++) {
 286                        if (info->seconds && time_after(time, e->stamps[i]))
 287                                continue;
 288                        if (!info->hit_count || ++hits >= info->hit_count) {
 289                                ret = !ret;
 290                                break;
 291                        }
 292                }
 293
 294                /* info->seconds must be non-zero */
 295                if (info->check_set & XT_RECENT_REAP)
 296                        recent_entry_reap(t, time);
 297        }
 298
 299        if (info->check_set & XT_RECENT_SET ||
 300            (info->check_set & XT_RECENT_UPDATE && ret)) {
 301                recent_entry_update(t, e);
 302                e->ttl = ttl;
 303        }
 304out:
 305        spin_unlock_bh(&recent_lock);
 306        return ret;
 307}
 308
 309static int recent_mt_check(const struct xt_mtchk_param *par)
 310{
 311        struct recent_net *recent_net = recent_pernet(par->net);
 312        const struct xt_recent_mtinfo *info = par->matchinfo;
 313        struct recent_table *t;
 314#ifdef CONFIG_PROC_FS
 315        struct proc_dir_entry *pde;
 316#endif
 317        unsigned i;
 318        int ret = -EINVAL;
 319
 320        if (unlikely(!hash_rnd_inited)) {
 321                get_random_bytes(&hash_rnd, sizeof(hash_rnd));
 322                hash_rnd_inited = true;
 323        }
 324        if (info->check_set & ~XT_RECENT_VALID_FLAGS) {
 325                pr_info("Unsupported user space flags (%08x)\n",
 326                        info->check_set);
 327                return -EINVAL;
 328        }
 329        if (hweight8(info->check_set &
 330                     (XT_RECENT_SET | XT_RECENT_REMOVE |
 331                      XT_RECENT_CHECK | XT_RECENT_UPDATE)) != 1)
 332                return -EINVAL;
 333        if ((info->check_set & (XT_RECENT_SET | XT_RECENT_REMOVE)) &&
 334            (info->seconds || info->hit_count ||
 335            (info->check_set & XT_RECENT_MODIFIERS)))
 336                return -EINVAL;
 337        if ((info->check_set & XT_RECENT_REAP) && !info->seconds)
 338                return -EINVAL;
 339        if (info->hit_count > ip_pkt_list_tot) {
 340                pr_info("hitcount (%u) is larger than "
 341                        "packets to be remembered (%u)\n",
 342                        info->hit_count, ip_pkt_list_tot);
 343                return -EINVAL;
 344        }
 345        if (info->name[0] == '\0' ||
 346            strnlen(info->name, XT_RECENT_NAME_LEN) == XT_RECENT_NAME_LEN)
 347                return -EINVAL;
 348
 349        mutex_lock(&recent_mutex);
 350        t = recent_table_lookup(recent_net, info->name);
 351        if (t != NULL) {
 352                t->refcnt++;
 353                ret = 0;
 354                goto out;
 355        }
 356
 357        t = kzalloc(sizeof(*t) + sizeof(t->iphash[0]) * ip_list_hash_size,
 358                    GFP_KERNEL);
 359        if (t == NULL) {
 360                ret = -ENOMEM;
 361                goto out;
 362        }
 363        t->refcnt = 1;
 364        strcpy(t->name, info->name);
 365        INIT_LIST_HEAD(&t->lru_list);
 366        for (i = 0; i < ip_list_hash_size; i++)
 367                INIT_LIST_HEAD(&t->iphash[i]);
 368#ifdef CONFIG_PROC_FS
 369        pde = proc_create_data(t->name, ip_list_perms, recent_net->xt_recent,
 370                  &recent_mt_fops, t);
 371        if (pde == NULL) {
 372                kfree(t);
 373                ret = -ENOMEM;
 374                goto out;
 375        }
 376        pde->uid = ip_list_uid;
 377        pde->gid = ip_list_gid;
 378#endif
 379        spin_lock_bh(&recent_lock);
 380        list_add_tail(&t->list, &recent_net->tables);
 381        spin_unlock_bh(&recent_lock);
 382        ret = 0;
 383out:
 384        mutex_unlock(&recent_mutex);
 385        return ret;
 386}
 387
 388static void recent_mt_destroy(const struct xt_mtdtor_param *par)
 389{
 390        struct recent_net *recent_net = recent_pernet(par->net);
 391        const struct xt_recent_mtinfo *info = par->matchinfo;
 392        struct recent_table *t;
 393
 394        mutex_lock(&recent_mutex);
 395        t = recent_table_lookup(recent_net, info->name);
 396        if (--t->refcnt == 0) {
 397                spin_lock_bh(&recent_lock);
 398                list_del(&t->list);
 399                spin_unlock_bh(&recent_lock);
 400#ifdef CONFIG_PROC_FS
 401                remove_proc_entry(t->name, recent_net->xt_recent);
 402#endif
 403                recent_table_flush(t);
 404                kfree(t);
 405        }
 406        mutex_unlock(&recent_mutex);
 407}
 408
 409#ifdef CONFIG_PROC_FS
 410struct recent_iter_state {
 411        const struct recent_table *table;
 412        unsigned int            bucket;
 413};
 414
 415static void *recent_seq_start(struct seq_file *seq, loff_t *pos)
 416        __acquires(recent_lock)
 417{
 418        struct recent_iter_state *st = seq->private;
 419        const struct recent_table *t = st->table;
 420        struct recent_entry *e;
 421        loff_t p = *pos;
 422
 423        spin_lock_bh(&recent_lock);
 424
 425        for (st->bucket = 0; st->bucket < ip_list_hash_size; st->bucket++)
 426                list_for_each_entry(e, &t->iphash[st->bucket], list)
 427                        if (p-- == 0)
 428                                return e;
 429        return NULL;
 430}
 431
 432static void *recent_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 433{
 434        struct recent_iter_state *st = seq->private;
 435        const struct recent_table *t = st->table;
 436        const struct recent_entry *e = v;
 437        const struct list_head *head = e->list.next;
 438
 439        while (head == &t->iphash[st->bucket]) {
 440                if (++st->bucket >= ip_list_hash_size)
 441                        return NULL;
 442                head = t->iphash[st->bucket].next;
 443        }
 444        (*pos)++;
 445        return list_entry(head, struct recent_entry, list);
 446}
 447
 448static void recent_seq_stop(struct seq_file *s, void *v)
 449        __releases(recent_lock)
 450{
 451        spin_unlock_bh(&recent_lock);
 452}
 453
 454static int recent_seq_show(struct seq_file *seq, void *v)
 455{
 456        const struct recent_entry *e = v;
 457        unsigned int i;
 458
 459        i = (e->index - 1) % ip_pkt_list_tot;
 460        if (e->family == NFPROTO_IPV4)
 461                seq_printf(seq, "src=%pI4 ttl: %u last_seen: %lu oldest_pkt: %u",
 462                           &e->addr.ip, e->ttl, e->stamps[i], e->index);
 463        else
 464                seq_printf(seq, "src=%pI6 ttl: %u last_seen: %lu oldest_pkt: %u",
 465                           &e->addr.in6, e->ttl, e->stamps[i], e->index);
 466        for (i = 0; i < e->nstamps; i++)
 467                seq_printf(seq, "%s %lu", i ? "," : "", e->stamps[i]);
 468        seq_printf(seq, "\n");
 469        return 0;
 470}
 471
 472static const struct seq_operations recent_seq_ops = {
 473        .start          = recent_seq_start,
 474        .next           = recent_seq_next,
 475        .stop           = recent_seq_stop,
 476        .show           = recent_seq_show,
 477};
 478
 479static int recent_seq_open(struct inode *inode, struct file *file)
 480{
 481        struct proc_dir_entry *pde = PDE(inode);
 482        struct recent_iter_state *st;
 483
 484        st = __seq_open_private(file, &recent_seq_ops, sizeof(*st));
 485        if (st == NULL)
 486                return -ENOMEM;
 487
 488        st->table    = pde->data;
 489        return 0;
 490}
 491
 492static ssize_t
 493recent_mt_proc_write(struct file *file, const char __user *input,
 494                     size_t size, loff_t *loff)
 495{
 496        const struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
 497        struct recent_table *t = pde->data;
 498        struct recent_entry *e;
 499        char buf[sizeof("+b335:1d35:1e55:dead:c0de:1715:5afe:c0de")];
 500        const char *c = buf;
 501        union nf_inet_addr addr = {};
 502        u_int16_t family;
 503        bool add, succ;
 504
 505        if (size == 0)
 506                return 0;
 507        if (size > sizeof(buf))
 508                size = sizeof(buf);
 509        if (copy_from_user(buf, input, size) != 0)
 510                return -EFAULT;
 511
 512        /* Strict protocol! */
 513        if (*loff != 0)
 514                return -ESPIPE;
 515        switch (*c) {
 516        case '/': /* flush table */
 517                spin_lock_bh(&recent_lock);
 518                recent_table_flush(t);
 519                spin_unlock_bh(&recent_lock);
 520                return size;
 521        case '-': /* remove address */
 522                add = false;
 523                break;
 524        case '+': /* add address */
 525                add = true;
 526                break;
 527        default:
 528                pr_info("Need \"+ip\", \"-ip\" or \"/\"\n");
 529                return -EINVAL;
 530        }
 531
 532        ++c;
 533        --size;
 534        if (strnchr(c, size, ':') != NULL) {
 535                family = NFPROTO_IPV6;
 536                succ   = in6_pton(c, size, (void *)&addr, '\n', NULL);
 537        } else {
 538                family = NFPROTO_IPV4;
 539                succ   = in4_pton(c, size, (void *)&addr, '\n', NULL);
 540        }
 541
 542        if (!succ) {
 543                pr_info("illegal address written to procfs\n");
 544                return -EINVAL;
 545        }
 546
 547        spin_lock_bh(&recent_lock);
 548        e = recent_entry_lookup(t, &addr, family, 0);
 549        if (e == NULL) {
 550                if (add)
 551                        recent_entry_init(t, &addr, family, 0);
 552        } else {
 553                if (add)
 554                        recent_entry_update(t, e);
 555                else
 556                        recent_entry_remove(t, e);
 557        }
 558        spin_unlock_bh(&recent_lock);
 559        /* Note we removed one above */
 560        *loff += size + 1;
 561        return size + 1;
 562}
 563
 564static const struct file_operations recent_mt_fops = {
 565        .open    = recent_seq_open,
 566        .read    = seq_read,
 567        .write   = recent_mt_proc_write,
 568        .release = seq_release_private,
 569        .owner   = THIS_MODULE,
 570};
 571
 572static int __net_init recent_proc_net_init(struct net *net)
 573{
 574        struct recent_net *recent_net = recent_pernet(net);
 575
 576        recent_net->xt_recent = proc_mkdir("xt_recent", net->proc_net);
 577        if (!recent_net->xt_recent)
 578                return -ENOMEM;
 579        return 0;
 580}
 581
 582static void __net_exit recent_proc_net_exit(struct net *net)
 583{
 584        proc_net_remove(net, "xt_recent");
 585}
 586#else
 587static inline int recent_proc_net_init(struct net *net)
 588{
 589        return 0;
 590}
 591
 592static inline void recent_proc_net_exit(struct net *net)
 593{
 594}
 595#endif /* CONFIG_PROC_FS */
 596
 597static int __net_init recent_net_init(struct net *net)
 598{
 599        struct recent_net *recent_net = recent_pernet(net);
 600
 601        INIT_LIST_HEAD(&recent_net->tables);
 602        return recent_proc_net_init(net);
 603}
 604
 605static void __net_exit recent_net_exit(struct net *net)
 606{
 607        struct recent_net *recent_net = recent_pernet(net);
 608
 609        BUG_ON(!list_empty(&recent_net->tables));
 610        recent_proc_net_exit(net);
 611}
 612
 613static struct pernet_operations recent_net_ops = {
 614        .init   = recent_net_init,
 615        .exit   = recent_net_exit,
 616        .id     = &recent_net_id,
 617        .size   = sizeof(struct recent_net),
 618};
 619
 620static struct xt_match recent_mt_reg[] __read_mostly = {
 621        {
 622                .name       = "recent",
 623                .revision   = 0,
 624                .family     = NFPROTO_IPV4,
 625                .match      = recent_mt,
 626                .matchsize  = sizeof(struct xt_recent_mtinfo),
 627                .checkentry = recent_mt_check,
 628                .destroy    = recent_mt_destroy,
 629                .me         = THIS_MODULE,
 630        },
 631        {
 632                .name       = "recent",
 633                .revision   = 0,
 634                .family     = NFPROTO_IPV6,
 635                .match      = recent_mt,
 636                .matchsize  = sizeof(struct xt_recent_mtinfo),
 637                .checkentry = recent_mt_check,
 638                .destroy    = recent_mt_destroy,
 639                .me         = THIS_MODULE,
 640        },
 641};
 642
 643static int __init recent_mt_init(void)
 644{
 645        int err;
 646
 647        if (!ip_list_tot || !ip_pkt_list_tot || ip_pkt_list_tot > 255)
 648                return -EINVAL;
 649        ip_list_hash_size = 1 << fls(ip_list_tot);
 650
 651        err = register_pernet_subsys(&recent_net_ops);
 652        if (err)
 653                return err;
 654        err = xt_register_matches(recent_mt_reg, ARRAY_SIZE(recent_mt_reg));
 655        if (err)
 656                unregister_pernet_subsys(&recent_net_ops);
 657        return err;
 658}
 659
 660static void __exit recent_mt_exit(void)
 661{
 662        xt_unregister_matches(recent_mt_reg, ARRAY_SIZE(recent_mt_reg));
 663        unregister_pernet_subsys(&recent_net_ops);
 664}
 665
 666module_init(recent_mt_init);
 667module_exit(recent_mt_exit);
 668
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.