Autonomically sending a message from kernel-module to user-space application without relying on the invoke of input. from user-space

Question

I will give a detailed exp of the program and lead to the issue regarding the use of netlink socket communication.
The last paragraph asks the actual question I need an answer for, so you might wanna start by peeking it first.

Disclaimer before I start:
- I have made an earlier search before asking here and did not find complete solution / alternative to my issue.
- I know how to initialize a module and insert it to kernel.
- I know to handle communication between module and user-space without using netlink sockets. Meaning using struct file_operations func pointers assignments to later be invoked by the module program whenever a user attempts to read/write etc. and answer to the user using copy_to_user / copy_from_user.
- This topic refers to Linux OS, Mint 17 dist.
- Language is C

Okay, so I am building a system with 3 components:
1. user.c : user application (user types commands here)
2. storage.c : storage device ('virtual' disk-on-key)
3. device.ko : kernel module (used as proxy between 1. and 2.)

The purpose of this system is to be able (as a user) to:
- Copy files to the virtual disk-on-key device (2) - like an "upload" from local directory that belongs to the user.
- Save files from the virtual device on local directory - like "download" from the device storage to the user directory.

Design:
Assuming programs (1),(2) are compiled and running + (3) has successfully inserted using the bash command ' sudo insmod device.ko ' , the following should work like this (simulation ofc):

Step 1 (in user.c) -> user types 'download file.txt'
Step 2 (in device.ko) -> the device recognizes the user have tried to 'write' to it (actually user just passing the string "download file.txt") and invokes the 'write' implementation of the method we set on struct file_operation earlier on module_init().
The device (kernel module) now passes the data (string with a command) to the storage.c application, expecting an answer to later be retrieved to the user.c application.
Step 3 (in storage.c) -> now, lets say this program performs a busy-wait loop of 'readmsg()' and that's how a request from module event is triggered and recognized, the storage device now recognizes that the module has sent a request (string with a command \ data). Now, the storage programs shall perform an implementation of some function 'X' to send the data requested using sendmsg() somewhere inside the function.

Now, here comes the issue. Usually, on all of the examples I've looked on web, the communication between the kernel-module and a user-space (or the storage.c program in our case) using netlink is triggered by the user-space and not vice versa. Meaning that the sendmsg() function from the user-space invokes the 'request(struct sk_buff *skb)' method (which is set on the module_init() part as following:

struct netlink_kernel_cfg cfg = {
    .input = request            // when storage.c sends something, it invokes the request function
};

so when the storage.c performs something like:

sendmsg(sock_fd,&msg,0);                        // send a msg to the module

the module invokes and runs the:

static void request(struct sk_buff *skb) {
    char *msg ="Hello from kernel";
    msg_size=strlen(msg);

    netlink_holder=(struct nlmsghdr*)skb->data;
    printk(KERN_INFO "Netlink received msg payload:%s\n",(char*)nlmsg_data(netlink_holder));

    pid = netlink_holder->nlmsg_pid;                                // pid of sending process 

    skb_out = nlmsg_new(msg_size,0);

    if(!skb_out){
        printk(KERN_ERR "Failed to allocate new skb\n");
        return;
    } 

    netlink_holder=nlmsg_put(skb_out,0,0,NLMSG_DONE,msg_size,0);    // add a new netlink message to an skb. more info: http://elixir.free-electrons.com/linux/v3.2/source/include/net/netlink.h#L491
    NETLINK_CB(skb_out).dst_group = 0;                              // not in multicast group
    strncpy(nlmsg_data(netlink_holder),msg,msg_size);               // assign data as char* (variable msg) 
    result=nlmsg_unicast(sock_netlink,skb_out,pid);                 // send data to storage. more info: http://elixir.free-electrons.com/linux/latest/source/include/net/netlink.h#L598

    if(result<0)
        printk(KERN_INFO "Error while sending bak to user\n");
}

and from all that big chunk, the only thing that im interesting in is actually doing this:

result=nlmsg_unicast(sock_netlink,skb_out,pid);                 // send data to storage.

BUT I can't use nlmsg_unicast() without having the strcut sk_buff* which is provided automatically for me whenever there's an invoke from storage.c !

To sum up everything:
How do I send a msg from the device.ko (kernel module) to the user-space withtout having to wait for request to invoke / rely on the provided strcut sk_buff parameter from the earlier shown 'request()' method ?

Hope this sums up the point. Thanks.

Answer 1

The only question here is that you need the user-space program connected to kernel-space first to get the pid of your user-program.

After get the pid, you can manually construct the skb_out and send it out through netlink_unicast or nlmsg_unicast.

The pid is always needed, you can set it as static and let your user-space program connect to your device.ko to make a long-maintained link.

Although this question is asked at 2017, I believe OP has already found the answer :D