Discussion :

[APommePote]

Bonjour,
Je suis entrain de développer une application dont une partie est un module linux (coté kernel). Pour fournir des données a ce module je développe aussi un programme client qui aura pour but d'envoyer des "chaines de caractères" par l'intermédiaire d'un socket.

Mon soucis vient du fait que je n'arrive pas a récupérer les messages coté kernel et que je n'arrive pas a arréter (complet_and_exit(); ) le kernel_thread qui se doit de recupérer les messages.

J'aimerai donc savoir si quelqu'un aurai un bout de code d'un serveur pour kernelspace a me montrer.

Si ca peut aidé ..
- la communication est forcément local entre le module et le programme.
- je sais qu'ouvrir un socket en mode kernel est déconseillé.
- d'auilleur si quelqu'un a une solution simple pour qu'un client puisse donner des valeurs a un serveur en module..

Merci d'avance.

[souviron34]

...- d'auilleur si quelqu'un a une solution simple pour qu'un client puisse donner des valeurs a un serveur en module..
..

Que veux-tu dire par là ??

[APommePote]

Que veux-tu dire par là ??

Si quelqu'un a une solution (qui n'utilise pas un socket) pour qu'un programme puisse communiquer avec un module linux.

[souviron34]

stdin ?
stdout ?

fichier ?

shared memory ?

Pourquoi veux-tu ouvrir le socket en mode kernel ?

[APommePote]

stdin ?
stdout ?

fichier ?

shared memory ?

Pourquoi veux-tu ouvrir le socket en mode kernel ?

C'était ma première idée et celle que j'ai pu le plus avancé.. concernant les segments de mémoires partagées comment on les utilises en kernel space ?

##edit
Dans quel header trouvé les fonctions relative a shmget par exemple, sachant que dans <linux/shm.h> elle n'y sont pas.
##finedit

Merci

[APommePote]

Je viens de modifier le titre car les segments de mémoires partagées sont peut être une meuilleur idée que l'utilisation d'un socket.
Par contre je ne parviens toujours pas a utiliser shmget et compagnie en kernelspace .. si quelqu'un a un morceau de code pour me guider ..

Merci.

[APommePote]

J'ai trouvé un article interresant sur la communication entre kernelspace et userspace.

http://www.linuxjournal.com/article/7356

En utilisant un socket Netlink.

--------------- Exemple de code pour le Module Linux ---

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include linux/config.h
#include linux/socket.h
#include linux/kernel.h
#include linux/module.h
#include linux/netlink.h
#include net/sock.h
 
#define NETLINK_TEST 17
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Test");
MODULE_DESCRIPTION("Testing Kernel/User socket");
 
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_TEST, 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);

--------------- Exemple de code pour le Programme ---

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
#include <sys/socket.h>
#include <linux/netlink.h>
 
 
#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);
 
}

Si cela peut aider quelqu'un dans le futur..

Merci !