小規模時のtcp_probeについて

輳制御を確認してグラフ化するのに最近tcp_probeを使用しています。

iperfとかで試す時には良いのですが、少ないパケットを送って

cat /proc/net/tcpprobe

等試すと全く何も表示されません。 (full=1オプションをつけてもダメ。。)

このままだと小規模で使えないので調べてみると

readで指定したバッファサイズ以上パケットがこないと処理をかえさなくなってました。 ということで通常のreadと同じようにパケットがあれば即返すように変更。

diff --git a/net/ipv4/tcp_probe.c b/net/ipv4/tcp_probe.c
index 3d063eb..309ff0a 100644
--- a/net/ipv4/tcp_probe.c
+++ b/net/ipv4/tcp_probe.c
@@ -207,17 +210,18 @@ static ssize_t tcpprobe_read(struct file *file, char __user *buf,
        if (!buf)
                return -EINVAL;
 
-       while (cnt < len) {
+       while (cnt == 0 || tcp_probe.head != tcp_probe.tail) {
                char tbuf[256];
                int width;
 
                /* Wait for data in buffer */
                error = wait_event_interruptible(tcp_probe.wait,
                                                 tcp_probe_used() > 0);
-               if (error)
-                       break;
-
+        if (error)
+            return error;
+        
                spin_lock_bh(&tcp_probe.lock);
+        /* double-checked locking */
                if (tcp_probe.head == tcp_probe.tail) {
                        /* multiple readers race? */
                        spin_unlock_bh(&tcp_probe.lock);
@@ -225,20 +229,20 @@ static ssize_t tcpprobe_read(struct file *file, char __user *buf,
                }
 
                width = tcpprobe_sprint(tbuf, sizeof(tbuf));
-
-               if (cnt + width < len)
-                       tcp_probe.tail = (tcp_probe.tail + 1) & (bufsize - 1);
-
                spin_unlock_bh(&tcp_probe.lock);
 
                /* if record greater than space available
                   return partial buffer (so far) */
-               if (cnt + width >= len)
+               if (cnt + width > len)
                        break;
 
+        tcp_probe.tail = (tcp_probe.tail + 1) & (bufsize - 1);
                if (copy_to_user(buf + cnt, tbuf, width))
                        return -EFAULT;
                cnt += width;
+
+               if (cnt ==  len) 
+                       break;
        }
 
        return cnt == 0 ? error : cnt;

tcp_probeについての使い方はこの辺りを参考にしてください https://wiki.linuxfoundation.org/networking/tcpprobe:tcpprobe

tcp_probeが入っていない場合はkernelのビルド時 CONFIG_NET_TCPPROBE=mに設定してください。

ip link経由でのドライバ追加

家にあるLinuxデバイスドライバの本のネットワークドライバのサンプルが古すぎて動かないので 4.9.57で動くようにしてついでに今風にipコマンド経由で追加できるように書き換えてみた。

最低限動くようにするところだけ移行。

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <net/rtnetlink.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/etherdevice.h>

MODULE_LICENSE("GPL");

#define MYQUEUE_RX_INTR 1

struct mynet_packet {
    struct mynet_packet *next;
    struct net_device *dev;
    int datalen;
    u8 data[ETH_DATA_LEN];
};

int mynet_newlink(struct net *net, struct net_device *dev, struct nlattr *tb[], struct nlattr *data[]);

static int pool_size = 8;

struct mynet_private {
    struct net_device *peer;
    int is_peer;
    struct mynet_packet *ppool;
    struct mynet_packet *rx_queue;
    spinlock_t lock;
    int status;
};

static void mynet_setup_pool(struct net_device *dev) {
    struct mynet_private *priv = netdev_priv(dev);
    struct mynet_packet *pkt;
    int i;
    priv->ppool = NULL;
    for ( i = 0; i < pool_size; ++i ) {
        pkt = kmalloc(sizeof(struct mynet_packet), GFP_KERNEL);
        if ( !pkt ) {
            printk(KERN_ERR "mynet setup pool error");
            return;
        }
        pkt->next = priv->ppool;
        pkt->dev = dev;
        pkt->datalen = 0;
        priv->ppool = pkt;
    }
}

static struct mynet_packet* mynet_get_tx_buffer(struct net_device *dev) {
    struct mynet_private *priv = netdev_priv(dev);
    struct mynet_packet *pkt;
    unsigned long flags;
    spin_lock_irqsave(&priv->lock, flags);
    pkt = priv->ppool;
    priv->ppool = pkt->next;
    pkt->next = NULL;

    if ( priv->ppool == NULL ) {
        netif_stop_queue(dev);
    }
    spin_unlock_irqrestore(&priv->lock, flags);
    return pkt;
}

void mynet_enqueue_buf(struct net_device *dev, struct mynet_packet *pkt) {
    unsigned long flag;
    struct mynet_private *priv = netdev_priv(dev);
    spin_lock_irqsave(&priv->lock, flag);
    pkt->next = priv->rx_queue;
    priv->rx_queue = pkt;
    spin_unlock_irqrestore(&priv->lock, flag);
}

void mynet_release_buffer(struct mynet_packet *pkt) {
    struct mynet_private *priv = netdev_priv(pkt->dev);
    unsigned long flags;
    spin_lock_irqsave(&priv->lock, flags);
    pkt->next = priv->ppool;
    priv->ppool = pkt;
    spin_unlock_irqrestore(&priv->lock, flags);
    if ( netif_queue_stopped(pkt->dev) && pkt->next == NULL ) {
        netif_wake_queue(pkt->dev);
    }

}

void print_mac(char *mac) {
    unsigned char buff[1024];
    int i, k = 0;

    for ( i = 0; i < ETH_ALEN; ++i ) {
        buff[++k] = hex_asc_hi(mac[i]);
        buff[++k] = hex_asc_hi(mac[i]);
        buff[++k] = ':';
    }

    buff[k-1] = '\0';
    printk("%s", buff);
}

static void mynet_rx(struct net_device *dev, struct mynet_packet *pkt) {
    struct sk_buff *skb;

    struct iphdr *iph;

    printk(KERN_DEBUG "mynet_rx");
    skb = dev_alloc_skb(pkt->datalen + 2);

    skb_reserve(skb, 2);
    iph = (struct iphdr*)(skb->data + sizeof(struct ethhdr));
    memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
    skb->dev = dev;
    skb->protocol = eth_type_trans(skb, dev);
    skb->ip_summed = CHECKSUM_UNNECESSARY;

    printk(KERN_DEBUG "||||protocol %d\n", skb->protocol);
    printk(KERN_DEBUG "||||len %d", pkt->datalen);
    printk(KERN_DEBUG "||||saddr : %pI4", &iph->saddr);
    printk(KERN_DEBUG "||||daddr : %pI4", &iph->daddr);

    netif_rx(skb);
}

static void mynet_interrupt(struct net_device *dev) {
    struct mynet_private *priv = netdev_priv(dev);
    struct mynet_packet *pkt = NULL;
    int status = priv->status;
    priv->status = 0;

    spin_lock(&priv->lock);
    if ( status & MYQUEUE_RX_INTR ) {
        pkt = priv->rx_queue;
        if ( pkt ) {
            priv->rx_queue = pkt->next;
            mynet_rx(dev, pkt);
        }
    }

    spin_unlock(&priv->lock);
}

netdev_tx_t mynet_start_xmit(struct sk_buff *skb, struct net_device *dev) {
    struct ethhdr *eh;
    struct iphdr *iph;
    struct mynet_private *priv, *peer_priv;
    u32 *saddr, *daddr;
    struct mynet_packet *tx_buffer;

    priv = netdev_priv(dev);
    peer_priv = netdev_priv(priv->peer);

    printk(KERN_WARNING "mynet xmit %s", dev->name);

    if ( !pskb_may_pull(skb, sizeof(struct iphdr) + sizeof(struct ethhdr)) ) {
        printk(KERN_DEBUG "can no read ether header\n");
        return NETDEV_TX_OK;
    }

    eh = (struct ethhdr*)skb->data;
    memcpy(eh->h_dest, priv->peer->dev_addr, ETH_ALEN);
    memcpy(eh->h_source, dev->dev_addr, ETH_ALEN);

    printk(KERN_DEBUG "addr len %d", dev->addr_len);
    printk(KERN_DEBUG "hard header len %d", dev->hard_header_len);
    iph = (struct iphdr*)((skb->data) + sizeof(struct ethhdr));
    printk(KERN_DEBUG "version: %d", iph->version);
    printk(KERN_DEBUG "saddr : %pI4", &iph->saddr);
    printk(KERN_DEBUG "daddr : %pI4", &iph->daddr);

    saddr = &iph->saddr;
    daddr = &iph->daddr;
    ((u8 *)saddr)[2] ^= 1;
    ((u8 *)daddr)[2] ^= 1;

    printk(KERN_DEBUG "=> saddr : %pI4", &iph->saddr);
    printk(KERN_DEBUG "=> daddr : %pI4", &iph->daddr);

    iph->check = 0;
    iph->check = ip_fast_csum((unsigned char*)iph, iph->ihl);

    tx_buffer = mynet_get_tx_buffer(dev);
    tx_buffer->datalen = skb->len;
    printk(KERN_DEBUG "||||len %d", skb->len);

    memcpy(tx_buffer->data, skb->data, skb->len);
    mynet_enqueue_buf(priv->peer, tx_buffer);

    peer_priv->status |= MYQUEUE_RX_INTR;
    mynet_interrupt(priv->peer);

    dev_kfree_skb(skb);

    return NETDEV_TX_OK;
}

int mynet_open(struct net_device *dev) {
    memcpy(dev->dev_addr, "\0TEST0", ETH_ALEN);
    if ( ((struct mynet_private*)netdev_priv(dev))->is_peer ) {
        dev->dev_addr[ETH_ALEN -1]++;
    }
    netif_start_queue(dev);
    return 0;
}

static struct net_device_ops mynet_ops = {
    .ndo_start_xmit = mynet_start_xmit,
    .ndo_open =  mynet_open,
};

void mynet_setup(struct net_device *dev) {
    struct mynet_private *priv;
    ether_setup(dev);
    dev->netdev_ops = &mynet_ops;
    dev->destructor = free_netdev;
    dev->flags = IFF_NOARP;
    mynet_setup_pool(dev);

    priv = netdev_priv(dev);
    spin_lock_init(&priv->lock);

}

void mynet_dellink(struct net_device *dev, struct list_head *head) {
    unregister_netdevice_queue(((struct mynet_private*)netdev_priv(dev))->peer, head);
    unregister_netdevice_queue(dev, head);
}

static struct rtnl_link_ops mynet_link_ops = {
    .kind = "mynet",
    .setup = mynet_setup,
    .newlink = mynet_newlink,
    .dellink = mynet_dellink,
    .priv_size  = sizeof(struct mynet_private),
};

int mynet_newlink(struct net *net, struct net_device *dev, struct nlattr *tb[], struct nlattr *data[]){
    struct net_device *peer = rtnl_create_link(net, "mynetpeer_%d", NET_NAME_ENUM, &mynet_link_ops, tb);
    ((struct mynet_private*)netdev_priv(peer))->is_peer = 1;
    printk("mynet newlink %p", peer);

    ((struct mynet_private*)netdev_priv(dev))->peer = peer;
    ((struct mynet_private*)netdev_priv(peer))->peer = dev;

    register_netdevice(dev);
    register_netdevice(peer);

    return 0;
}

static int init_mynet(void) {
    printk(KERN_DEBUG "===========-mynet init==========");
    return rtnl_link_register(&mynet_link_ops);
}

static void exit_mynet(void) {
    rtnl_link_unregister(&mynet_link_ops);
}

module_init(init_mynet);
module_exit(exit_mynet);

追加するスクリプトはこんな感じ

#!/bin/sh
FLAG_D=0

while getopts d OPT
do
    case $OPT in
        d) FLAG_D=1
        ;;
    esac
done

if [ $FLAG_D -eq 0 ];
then
    echo "install"
    insmod mynet.ko
    ip link add mynet0 type mynet
    ip link set mynet0 up
    ip link set mynetpeer_0 up

    ip addr add dev mynet0 1.1.0.1/24
    ip addr add dev mynetpeer_0 1.1.1.2/24
else
    echo "uninstall"
    ip link del mynet0
    rmmod mynet
fi    

ping 1.1.0.2でpingが通ることが確認できる

conntrackの勉強(1)

conntrackのフック

IPTableと同じようにNetFilter経由で実装されている。

使用しているフックは

• PREROUTING => ipv4_conntrack_in
• LOCAL_OUT => ipv4_conntrack_local
• POSTROUTING => ipv4_confirm
• NF_INET_LOCAL_IN => ipv4_confirm

となっている。

フックの優先順位

優先順位は

enum nf_ip_hook_priorities {
...
    NF_IP_PRI_CONNTRACK = -200,           
    NF_IP_PRI_MANGLE = -150,              
    NF_IP_PRI_NAT_DST = -100,             
    NF_IP_PRI_FILTER = 0,                 
    NF_IP_PRI_SECURITY = 50,              
    NF_IP_PRI_NAT_SRC = 100,              
    NF_IP_PRI_SELINUX_LAST = 225,         
    NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX,
...
}

のようになっており、 iptablesとの関係は PREROUTING, OUTPUTでIPTABLESの処理に入る前に 必ずconntrackを作るをようになっており、 POSTROUTING,INPUTで登録を行うが、こちらはIPTABLESでフィルタをかけられたものは登録されないようになっている。

nf_conntrackとsk_buffの関連付け

PREROUTINGとINPUTのskbufにconntrackの関連付けを行う skbufに結び付けられるconntrackのパラメータは以下の二つ

struct sk_buff {
...
    struct nf_conntrack *nfct;
    __u8 nfctinfo:3;
...
}

nf_conntrackは実際にはnf_connが入っている。 nfctinfoはステータスが入り、ステータスは以下の5パターンがある

• IP_CT_ESTABLISHED,
• IP_CT_RELATED,
• IP_CT_NEW,
• IP_CT_IS_REPLY + IP_CT_ESTABLISHED
• IP_CT_IS_REPLY + IP_CT_RELATED

nf_conntrack_tuple

nf_connに結びついていてるハッシュのに使われるタプル情報 conntrackでは行きと戻り、両方をペアとして保存する必要があるため、 nc_conn構造体には２つのタプル情報がある

struct nf_conntrack_tuple_hash {        
    struct hlist_nulls_node hnnode;     
    struct nf_conntrack_tuple tuple;    
};           

struct nf_conn {
...
    struct nf_conntrack_tuple_hash tuplehash[IP_CT_DIR_MAX];
....
}

enum ip_conntrack_dir {
    IP_CT_DIR_ORIGINAL,
    IP_CT_DIR_REPLY,
    IP_CT_DIR_MAX
};    

IP_CT_DIR_ORIGINALが行きパケットで、IP_CT_REPLYが戻りパケットになる。

nf_conntrack_tupleには以下の情報が入っている

• l3proto
• l2proto
• 送信元IP
• 送信元port
• 送信先IP
• 送信先port
• direction

実際にハッシュ値を生成するときはdirectionは含まれておらず、 これはtupleからnf_conntrackを取得する際に使われる。 directionがわかることで以下のようにnf_connの位置がわかりtupleからnf_connを取得できる

static inline struct nf_conn *                                        
nf_ct_tuplehash_to_ctrack(const struct nf_conntrack_tuple_hash *hash) 
{                                                                     
    return container_of(hash, struct nf_conn,                         
                tuplehash[hash->tuple.dst.dir]);                      
}                                                                     

tupleの管理

tupleはネームスペースごとに管理される net->netns_ct->hashがハッシュ情報となる。 ハッシュに入るのはPOSTROUTINGとINPUT時なのでそれまでの間、 ハッシュに入っていないtuple情報はnet->netns_ct->unconfirmedで管理される。

insertは__nf_conntrack_hash_insertで行われる。 行きと戻りセットで入れるため、ORIGINALとREPLY両方のinsertが行われる。

iptablesの勉強(4)

ユーザ定義チェインについて

ユーザ定義チェイン

ユーザ定義チェインは先頭と末尾に固定のipt_entryを持ったエントリとして定義される。

先頭のipt_entryはチェインの名前を示す。 チェインの名前はxt_get_revision.nameに格納される。

末尾のipt_entryはチェインから戻るための情報を持っていて xt_standard_targetとなる。 ビルドインチェインの場合末尾にはポリシーによってACCEPTやDROPが入っていたが、 ユーザ定義チェインの場合はチェインから戻るためのRETURNが入る。

ユーザ定義チェインへのジャンプ

チェインへのJUMPターゲット(-j <ユーザ定義チェイン>)を指定した場合、 ユーザ空間のiptablesコマンド内で、ユーザ定義名ではなく、xt_standard_targetのverdictとして次のエントリへのオフセットが格納される

struct xt_standard_target {        
    struct xt_entry_target target; 
    int verdict;                   
};

verdictの値はカーネル空間でチェックされ、同時に無限ループしていないかもチェックされる。

スタックについて

スタックのデータ構造

xt_table_infoにはJUMPから戻れるようにスタックを用意している。

    unsigned int stacksize;
    unsigned int __percpu *stackptr;
    void ***jumpstack;

• stacksize => チェインはループすることがないのでスタックサイズはユーザチェインの数となる。
• stackptr => 現在のスタック位置(CPUごとに保持する)
• jumpstack[cpu個数][stacksize]　=> jumpした時のipt_entryのポインタをCPUごとに保存する

ipt_do_tableにて以下のように設定と取り出しを行なっている

jumpstack  = (struct ipt_entry **)xt_table_info->jumpstack[cpu];

// JUMP時
jumpstack[(*stackptr)++] = e;

// RETURN時
e = jumpstack[--*stackptr]; 
e = ipt_next_entry(e);

スタックサイズの決定

スタックサイズはnet/ipv4/netfilter/ip_tables.c:translate_table内で XT_ERROR_TARGETの数をカウントしている。 XT_ERROR_TARGETはtargetとして設定されることがないので XT_ERROR_TARGETの数 == チェインの数となる模様

このターゲットに処理が来ることはないが、もしも処理が来た場合には ログを出してドロップする処理になっている。

ユーザ定義チェインのループチェック

ユーザ定義チェインは同じチェインにループしないように

do_ipt_set_ctl
    do_replace
        translate_table
            mark_source_chains

にてチェインのループチェックをおこなっている。

iptablesの勉強(3)

引き続きiptablesの勉強中

今回はカーネルのデータ構造とiptablesで表示されるデータについて

カーネル内でのデータの保持

カーネル内ではxt_tableというデータで保持されている

タスクからのアクセスはnetns_ipv4経由で

task_struct->ns_proxy->net_ns->ipv4

struct netns_ipv4 {
...
    struct xt_table     *iptable_filter; 
    struct xt_table     *iptable_mangle; 
    struct xt_table     *iptable_raw;    
...
}

にてそれぞれテーブルごとのxt_tableにアクセスできる。

xt_table

xt_tableではカウンタの更新時にロックを取らないようにするため CPUごとにテーブル情報をコピーして保存している

valid_hookにはテーブルで有効なチェインのビットフラグ

enum nf_inet_hooks {      
    NF_INET_PRE_ROUTING,  
    NF_INET_LOCAL_IN,     
    NF_INET_FORWARD,      
    NF_INET_LOCAL_OUT,    
    NF_INET_POST_ROUTING, 
    NF_INET_NUMHOOKS      
};

nameには"filter"等のテーブル名が入っている

xt_table_info

xt_table_infoにはテーブルごとの情報が入っている 例えば

[root@localhost linux-2.6.39]# iptables -L 
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
           all  --  anywhere             anywhere            
           all  --  anywhere             anywhere            

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         
           all  --  anywhere             anywhere            
           all  --  anywhere             anywhere            
           all  --  anywhere             anywhere            

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         
           all  --  anywhere             anywhere   

のようにINPUT2つ,FORWARD3つ,OUTPUT1つある場合には

のように格納される

hook_entriesにchain内の最初の要素、under_flowにchain内の最後の要素が格納される。

ipt_entry

ipt_entryにはルール一つが入る。 ルールには汎用マッチと(iptablesの-iや-o, -sなどの全てのルールに固有の情報)と、 -m等で明示的に指定するマッチがある(暗黙的なマッチも明示的なマッチになる)

マッチは複数入り、-jで指定するターゲットは１つだけとなる。 マッチへのアクセスはelemsにて、 次のマッチへのアクセスはu.match_size分シフト。 target_offsetまで行くとターゲットとなる。

ソースルーティング

IPのオプションを指定してLinuxで経路を指定してパケットを出す方法を調べてみた

設定方法

IPのオプションを指定する方法は以下の2通りがある

• ソケット単位に指定する setsockoptでIP_OPTIONSを指定する

• パケット単位で設定を変える sendmsgのstruct msghdr->msg_controlにIP_RETOPTのCMSGを設定する

今回はソケット単位に指定する方法を使用

ソース

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/udp.h>

#include <linux/ip.h>

void main() {
    unsigned char options[256] = {0};
    options[0] = IPOPT_LSRR; // type
    int len = 11;
    options[1] = len; // len;
    options[2] = 4; // pointer

    struct in_addr addr;
    inet_aton("1.1.1.1", &addr);
    *((uint32_t*)(options + 3))  = addr.s_addr;

    inet_aton("2.2.2.2", &addr);
    *((uint32_t*)(options + 7))  = addr.s_addr;
    options[7] = IPOPT_NOOP;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if ( sock == -1 ) {
        perror("creat socket error\n");
        exit(1);
    }

    if ( setsockopt(sock, SOL_IP, IP_OPTIONS, options, len) == -1 ) {
        perror("set ip options error\n");
        exit(1);
    }

    struct sockaddr_in sin;
    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_port = htons(8080);
    inet_aton("3.3.3.3", &sin.sin_addr);

    char buf[] = "test";
    int ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sin, sizeof(sin));
    printf("%d\n", ret);
}

動作

ソースルーティングはoptionで指定されているものが送信先となる。 この場合1.1.1.1 => 2.2.2.2 => 3.3.3.3という経路になるので 送信先が1.1.1.1となる。 sendで指定されたものは送信先ではなく、経路の最後に追加される。

処理しているのはLinuxカーネルのnet/ipv4/ip_options.c:ip_options_compile周り

ルータの設定

デフォルトではLinuxをルータとして使用している場合ip_forwardを有効にしてもソースルーティングは有効にならない。

echo "1" > /proc/sys/net/ipv4/conf/all/accept_source_route 

を実行して使用したいデバイスの

echo "1" > /proc/sys/net/ipv4/conf/<dev>/accept_source_route

sourceルーティングを有効にしておく必要がある

カーネルからユーザ空間にnetlinkブロードキャスト

iptablesのULOGを調べててカーネル空間にnetlinkにブロードキャストを送る方法が気になったので書いてみた

カーネル空間のプログラム

#include <linux/socket.h>                                                     
#include <net/sock.h>                                                         
                                                                              
static struct timer_list my_timer;                                            
static struct sock *sock;                                                     
static int seq;                                                               
                                                                              
MODULE_LICENSE("GPL");                                                        
                                                                              
void my_timer_callback( unsigned long data ) {                                
    char word[] = "hello world!";                                             
    struct sk_buff *skb;                                                      
    int type = 0;                                                             
    struct nlmsghdr *nlh;                                                     
    char *d;                                                                  
    int ret;                                                                  
                                                                              
    printk("timeout\n");                                                      
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(200));                    
                                                                              
                                                                              
    skb = alloc_skb(1024, GFP_ATOMIC);                                        
    if ( !skb ) {                                                             
        printk("error: skb alloc\n");                                         
        return;                                                               
    }                                                                         
                                                                              
    nlh = NLMSG_PUT(skb, 0, ++seq, type, strlen(word));                       
    d = NLMSG_DATA(nlh);                                                      
    memcpy(d, word, strlen(word));                                            
                                                                              
    ret = netlink_broadcast(sock, skb, 0, 5, GFP_ATOMIC);                                 
                                                                              
    return;                                                                   
                                                                              
nlmsg_failure:                                                                
    printk("error:NLMSG_PUT\n");                                              
    return;                                                                   
}                                                                             
                                                                              
int myrtnl_init(void) {                                                       
                                                                              
    sock = netlink_kernel_create(&init_net, 20, 32, NULL, NULL, THIS_MODULE); 
    if ( !sock ) {                                                            
        printk("error: netlink kernel create\n");                             
        return 1;                                                             
    }                                                                         
                                                                              
    setup_timer(&my_timer, my_timer_callback, 0);                             
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(200));                    
    return 0;                                                                 
}                                                                             
                                                                              
void myrtnl_exit(void) {                                                      
    del_timer(&my_timer);                                                     
    netlink_kernel_release(sock);                                             
}                                                                             
                                                                              
module_init(myrtnl_init);                                                     
module_exit(myrtnl_exit);                                                     

200ミリ秒ごとにNETLINKにブロードキャストを送るプログラム

cat /proc/net/netlink で空いてるをとりあえず使ってみた。（ルールは今度ちゃんと調べる）

netlink_broadcastにsk_buffを渡せば作れる。

NLMSG_PUTというショートカットメソッドも用意されている。

ユーザ空間のプログラム

#include <stdio.h>                                                               
#include <libnetlink.h>                                                          
#include <stdlib.h>                                                              
#include <string.h>                                                              
                                                                                 
int listen_handler(const struct sockaddr_nl *nl, struct nlmsghdr *n, void *arg) {
    char buf[256] = {0};                                                         
    memcpy(buf, NLMSG_DATA(n), 12);                                              
    printf("data: %s\n", buf);                                                   
    return 0;                                                                    
}                                                                                
void main() {                                                                    
    struct rtnl_handle rh;                                                       
    int n = 5;                                                                   
    if ( rtnl_open_byproto(&rh, 1 << (n - 1), 20) != 0 ) {                       
        perror("open error\n");                                                  
        exit(1);                                                                 
    }                                                                            
                                                                                 
    printf("listen start\n");                                                    
    rtnl_listen(&rh, listen_handler, NULL);                                      
}                                                                                

libnetlinkを使った受信

ユーザ空間のグループ指定はビットシフトになるので注意

出力結果

[root@localhost rtnetlink]# ./a.out 
listen start                        
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!                  
data: hello world!