Kernel Korner - Why and How to Use Netlink Socket

Hi,

Can anybody tell me how to read the flags of assigned IPv6 address.
I am basically trying to retrieve the value of IFA_F_TENTATIVE of ifaddrmsg structure from user level program.

Thanks,
-Krishna

I tried to modify this for latest kernel... but when kernel send msg to user space, kernel hangs after few seconds... I am not able to figure out the problem

// KERNEL MODULE

#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 

DEFINE_MUTEX(mut);

#define KNETLINK_UNIT 17

static struct sock * knetlink_sk = NULL;
char data_string[] = "Hello Userspace! This is msg from Kernel";

int knetlink_process( struct sk_buff * skb, struct nlmsghdr *nlh )
{
        u8 * payload = NULL;
        int   payload_size;
        int   length;
        int   seq;
        pid_t pid;
        struct sk_buff * rskb;

        pid = nlh->nlmsg_pid;
        length = nlh->nlmsg_len;
        seq = nlh->nlmsg_seq;
        printk("\nknetlink_process: nlmsg len %d type %d pid %d seq %d\n",
                        length, nlh->nlmsg_type, pid, seq );
        /* process the paylad */
        payload_size = nlh->nlmsg_len - NLMSG_LENGTH(0);
        if ( payload_size > 0 ) {
                payload = NLMSG_DATA( nlh );
                printk("\nknetlink_process: Payload is %s ", payload);
        }
        // reply
        rskb = alloc_skb( nlh->nlmsg_len, GFP_KERNEL );
        if ( rskb ) {
                memcpy( rskb->data, skb->data, length );
                skb_put( rskb, length );
                kfree_skb( skb );
        } else {
                printk("knetlink_process: replies with the same socket_buffer\n");
                rskb = skb;
        }
        memset(rskb->data, 0, length);
        nlh = (struct nlmsghdr *) rskb->data;
        nlh->nlmsg_len   = length;
        nlh->nlmsg_pid   = 0; //from kernel
        nlh->nlmsg_flags = NLM_F_REQUEST;
        nlh->nlmsg_type  = 2;
        nlh->nlmsg_seq   = seq+1;
        payload = NLMSG_DATA( nlh );

        printk("knetlink_process: reply nlmsg len %d type %d pid %d\n",
                        nlh->nlmsg_len, nlh->nlmsg_type, nlh->nlmsg_pid );
        strcpy(payload, data_string);
        *(payload + strlen(data_string)) = '\0';
        netlink_unicast( knetlink_sk, rskb, pid, MSG_DONTWAIT );
        return 0;
}

// USER SPACE CODE

#include 
#include 
#include 
#include 
#include 

#define KNETLINK_UNIT   17
#define MAX_PAYLOAD 1024  /* maximum payload size*/
struct sockaddr_nl src_addr, dst_addr;
struct msghdr msg;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
int sock_fd;

char data_string[] = "Hello Kernel! This is user space message";

int main()
{
        sock_fd = socket(PF_NETLINK, SOCK_RAW, KNETLINK_UNIT);
        char *data = NULL;

        memset(&src_addr, 0, sizeof(src_addr));
        src_addr.nl_family = AF_NETLINK;
        src_addr.nl_pid = getpid();
        src_addr.nl_groups = 0; // no multicast
        bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));

        memset(&dst_addr, 0, sizeof(dst_addr));
        dst_addr.nl_family = AF_NETLINK;
        dst_addr.nl_pid = 0; // 0 means kernel
        dst_addr.nl_groups = 0; // no multicast

        nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));

        memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
        /* Fill the netlink message header */
        nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
        nlh->nlmsg_pid = getpid();
        // I dont know what to set nlmsg_flags and nlmsg_type
        nlh->nlmsg_flags = NLM_F_REQUEST;
        nlh->nlmsg_type = NLMSG_MIN_TYPE +1;


        strcpy(NLMSG_DATA(nlh), data_string);
        *((char*)NLMSG_DATA(nlh) + strlen(data_string)) = '\0';

        iov.iov_base = (void *)nlh;
        iov.iov_len = nlh->nlmsg_len;

        msg.msg_name = (void *)&dst_addr;
        msg.msg_namelen = sizeof(dst_addr);
        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;

        sendmsg(sock_fd, &msg, 0);

        /* Read message from kernel */
        memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
        recvmsg(sock_fd, &msg, 0);
        printf("\nReceived message payload: %s\n", NLMSG_DATA(nlh));

        close(sock_fd);

        return 1;
}
             
void knetlink_input( struct sk_buff * skb)
{
        mutex_lock(&mut);
        printk("\nFunction %s() called", __FUNCTION__);

        netlink_rcv_skb(skb, &knetlink_process);

        mutex_unlock(&mut);
}

int knetlink_init( void )
{
        if ( knetlink_sk != NULL ) {
                printk("knetlink_init: sock already present\n");
                return 1;
        }

        knetlink_sk = netlink_kernel_create(&init_net, KNETLINK_UNIT, 0, knetlink_input, NULL, THIS_MODULE);
        if ( knetlink_sk == NULL ) {
                printk("knetlink_init: sock fail\n");
                return 1;
        }

        printk("knetlink_init: sock %p\n", (void*)knetlink_sk );
        return 0;
}

void knetlink_exit( void )
{
        if ( knetlink_sk != NULL ) {
                printk("knetlink_exit: release sock %p\n", (void*)knetlink_sk);
                sock_release( knetlink_sk->sk_socket );
        } else {
                printk("knetlink_exit: warning sock is NULL\n");
        }

}

module_init( knetlink_init );
module_exit( knetlink_exit );

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Prashant Bhole");
MODULE_DESCRIPTION("Netlink Demo");

Hi,

Please let me know the following problem is a real issue or not?

I have written a program using generic netlinks to communicate to/from kernel space. The user program sends a string and expects two strings from the kernel.

The program is working well and as expected kernel sends two hello strings to the user.

But the problem is kernel is sending one more message on the same socket which I don't expect.
I.e after the first two reads on the socket, the third should block for the data until kernel sends further messages. But instead of blocking, the third read in the user application reads a message which seems to be an error message from kernel.

Please check below for the message prints from kernel.

On first socket read using recv(......)

38 00 00 00 30 00 00 00 1F 13 24 49 00 00 00 00 8 . . . 0 . . . . . $ I . . . . 01 01 00 00 22 00 01 00 68 65 6C 6C 6F 20 77 6F . . . . " . . . h e l l o w o
72 6C 64 20 66 72 6F 6D 20 6B 65 72 6E 65 6C 20 r l d f r o m k e r n e l 73 70 61 63 65 00 00 00 s p a c e . . .

second read

40 00 00 00 30 00 00 00 1F 13 24 49 00 00 00 00 @ . . . 0 . . . . . $ I . . . .
01 01 00 00 29 00 01 00 53 65 63 6F 6E 64 20 68 . . . . ) . . . S e c o n d h
65 6C 6C 6F 20 77 6F 72 6C 64 20 66 72 6F 6D 20 e l l o w o r l d f r o m
6B 65 72 6E 65 6C 20 73 70 61 63 65 00 00 00 00 k e r n e l s p a c e . . . .

Third read which should block is receiving following
message from kernel which I think is a bug.

24 00 00 00 02 00 00 00 1E 13 24 49 68 39 00 00 $ . . . . . . . . . $ I h 9 . .
00 00 00 00 30 00 00 00 30 00 05 00 1E 13 24 49 . . . . 0 . . . 0 . . . . . $ I
68 39 00 00 h 9 . .

The third message is not sent by my kernel generic driver but is always received in the user application.

Please help resolve the above issue.

Thanks in advance.....

HI all,

Through Netlink sockets,Kernel echoes! -->Only echoes possible?

Rather than expecting an echo message from kernel,can user by some means ask Kernel to send an expected reply.?
I will make things more clear.
Scenario:

I am expecting messages from kernel on any USB plug in.I am able to receive then also through netlink sockets.But if the USB is already plugged in,Kernel fails to send a message to user space.Can I demand a USB plug in /plug out message from Kernel by sending my requirement through sendmsg()!! -- :)

Responses appreciated.Thanks in advance.
Ajith

Great article. Helped me alot to get my code ported to 2.6. Thanks.

Shell/PERL/etc apps can use /proc on any distro without having to rebuild the app or worry about library incompatibilities. Conscientious developers are cautious when changing the /proc contents since hundreds of apps could be using the information... The netlink infrastructure may be more efficient, but how would the wealth of information provided by /proc be made available to system administrators as easily as /proc is via cat, less, or grep? How can I get information from netlink using those applications? The /proc support does have its advantages. Netlink is not the silver bullet.

Howerver, this is a great netlink article!

thanks for your article it is very useful . i try to create communication socket beetwin Kernel module and user land program . i used you proposed code . but it is not worked correctly . i compile my module and userland code correctly but there is no communication between them .
please , It would be nice if you could add working or at least compilable examples.

best regard's
M.taghiloo

/* Working version of the Netlink Socket code from Linux Journal's Kernel Korner */
#include
#include
#include
#include
#include
#include

#define MAX_PAYLOAD 1024
struct sockaddr_nl src_addr, dst_addr;
struct nlmsghdr *nlh = NULL;
struct msghdr msg;
struct iovec iov;
int sock_fd;

int main()
{
sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_NITRO);

memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid();
src_addr.nl_groups = 0; // no multicast
bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));

memset(&dst_addr, 0, sizeof(dst_addr));
dst_addr.nl_family = AF_NETLINK;
dst_addr.nl_pid = 0; // 0 means kernel
dst_addr.nl_groups = 0; // no multicast

nlh = (struct nlhmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));

/* Fill the netlink message header */
nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;

strcpy(NLMSG_DATA(nlh), "Yoo-hoo, Mr. Kernel!");

iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;

msg.msg_name = (void *)&dst_addr;
msg.msg_namelen = sizeof(dst_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;

sendmsg(sock_fd, &msg, 0);

/* Read message from kernel */
memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
recvmsg(sock_fd, &msg, 0);
printf("Received message payload: %s\n", NLMSG_DATA(nlh));

close(sock_fd);

return (EXIT_SUCCESS);

}

/* The Linux Journal Kernel Korner -- Working, compiling version of the kernel code */
#include
#include
#include
#include
#include
#include
#include

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Daniel Purcell");
MODULE_DESCRIPTION("Kernel Korner's working versinon of netlink sockets");

// Note: Debug is not implemented
static int debug = 0;

module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug information (default 0)");

static struct sock *nl_sk = NULL;

static void nl_data_ready (struct sock *sk, int len)
{
wake_up_interruptible(sk->sk_sleep);
}

static void netlink_test()
{
struct sk_buff *skb = NULL;
struct nlmsghdr *nlh = NULL;
int err;
u32 pid;

nl_sk = netlink_kernel_create(NETLINK_NITRO, nl_data_ready);
skb = skb_recv_datagram(nl_sk, 0, 0, &err);

nlh = (struct nlmsghdr *)skb->data;
printk(KERN_INFO "%s: received netlink message payload: %s\n", __FUNCTION__, NLMSG_DATA(nlh));

pid = nlh->nlmsg_pid;
NETLINK_CB(skb).groups = 0;
NETLINK_CB(skb).pid = 0;
NETLINK_CB(skb).dst_pid = pid;
NETLINK_CB(skb).dst_groups = 0;
netlink_unicast(nl_sk, skb, pid, MSG_DONTWAIT);
sock_release(nl_sk->sk_socket);
}

static int __init my_module_init(void)
{
printk(KERN_INFO "Initializing Netlink Socket");
netlink_test();
return 0;
}

static void __exit my_module_exit(void)
{
printk(KERN_INFO "Goodbye");
}

module_init(my_module_init);
module_exit(my_module_exit);