Discussion :

[jobe]

Bonjour,

J'ai soigneusement suivit le tutorat (dispo sur ce site) de Benjamin Roux sur l'ecriture de drivers linux en C.
Malheureusement certains point de sont pas très claire pour moi et je rencontre des erreurs:

Lors de l'ecriture de caractères vers le drivers avec la commande suivante:
cat salut.txt > /dev/ezdriver
j'obtient le message d'erreur suivant : cat: erreur d'écriture: Aucun espace disponible sur le périphérique

Pourtant au niveau de mon périphérique le message est bien reçu en effet dmesg | tail donne :

Code :

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

1
2
3
4
5
6
7
8
[17183863.468000] ezdriver: open
[17183863.492000] ezdriver: write
[17183863.492000] ezdriver: demande d'ecriture de 6 octets
[17183863.492000] ezdriver: 6 octets réellement écrits
[17183863.492000] ezdriver: position=6
[17183863.492000] ezdriver: contenu du buffer salut
[17183863.492000]  73 61 6C 75 74 A 0 0 0 0 0 0 0 0 0 0 E 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 88 AA 15 CD 88 AA 15 CD F0 96 33 C0 C0 99 FE DF 13 0 0 0 0 0 0 0
[17183863.540000] ezdriver: close

Merci pour vos pistes

Jobe

P.S. voici le code complet

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
 
MODULE_AUTHOR("Jobe");
MODULE_DESCRIPTION("Driver minimaliste pour des tests");
MODULE_SUPPORTED_DEVICE("aucune");
MODULE_LICENSE("GPL");
 
#define DRIVER_NAME "ezDriver"
static int buf_size = 64;
static char *buffer;
 
//paramètre pour le numéro major
static int major = 254;
module_param(major, int, 0);
MODULE_PARM_DESC(major, "major number");
 
/***************************************************************************
 Accès au drivers
***************************************************************************/
 
 
static ssize_t ezdriver_read(struct file *file, char *buf, size_t count, loff_t *ppos)
{
	printk(KERN_DEBUG "ezdriver: read\n");
	return 0;
}
 
static ssize_t ezdriver_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
	int ecrits = 0;
	int i = 0;
 
	printk(KERN_DEBUG "ezdriver: write\n");
 
	printk(KERN_DEBUG "ezdriver: demande d'ecriture de %d octets \n", count);
	//calcule la taille réellement écrit en fonction de la taille du buffer et de la position
	if(count <= buf_size - (int)*ppos)
		ecrits = count;
	else
		ecrits = buf_size - (int)*ppos;
 
	if(ecrits)
		copy_from_user((int*)buffer + (int)*ppos, buf, ecrits);
	*ppos += ecrits;
	printk(KERN_DEBUG "ezdriver: %d octets réellement écrits \n", ecrits);
	printk(KERN_DEBUG "ezdriver: position=%d \n", (int)*ppos);
	printk(KERN_DEBUG "ezdriver: contenu du buffer %s", buffer);
	for(i=0;i<buf_size;i++)
		printk(" %X", buffer[i]);
	printk("\n");
 
 
 
	return 0;
}
 
static ssize_t ezdriver_open(struct inode *inode, struct file *file)
{
	printk(KERN_DEBUG "ezdriver: open\n");
	buffer = kmalloc(64, GFP_KERNEL);
	if(buffer == NULL)
	{
		printk(KERN_ERR "ezdriver: kmalloc a provoquer un erreur");
		return -1;
	}
	return 0;
}
 
static ssize_t ezdriver_close(struct inode *inode, struct file *file)
{
	printk(KERN_DEBUG "ezdriver: close\n");
	kfree(buffer);
	buffer = NULL;
	return 0;
}
 
 
struct file_operations fops =
{
	.read = ezdriver_read,
	.write = ezdriver_write,
	.open =  ezdriver_open,
	.release = ezdriver_close
};
 
/***************************************************************************
 Initialisations du driver
***************************************************************************/
static int __init ezdriver_init(void)
{
	if(register_chrdev(major, DRIVER_NAME, &fops) < 0)
		printk(KERN_ERR "ezDriver: register_chrdev à provoquer un erreur\n");
	else
		printk(KERN_DEBUG "ezDriver: register_chrdev executé normallement\n");
	return 0;
}
 
/***************************************************************************
 Nettoyage du driver
***************************************************************************/
static void __exit ezdriver_cleanup(void)
{
	if(unregister_chrdev(major, DRIVER_NAME) < 0)
		printk(KERN_ERR "ezDriver: unregister_chrdev à provoquer un erreur\n");
	else
		printk(KERN_DEBUG "ezDriver: unregister_chrdev executé normallement\n");
}
 
 
 
module_init(ezdriver_init);
module_exit(ezdriver_cleanup);

[valefor]

Est-ce que les fonction ezdriver_read/write ne devraient pas renvoyer le nombre d'octets lus/écrits ? Ou un code d'erreur style EOF si erreur.

[D[r]eadLock]

2.5. Méthodes read et write
Ces 2 méthodes renvoient le nombre d'octets, lus pour read et écrits pour write.

Après, tu peux utiliser strace pour voir les résultat des appels systeme (strace -o trace cat ...)

Et

Code :

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

1
2
3
4
5
6
 
static int buf_size = 64;
...
	if(count <= buf_size - (int)*ppos)
...
	buffer = kmalloc(64, GFP_KERNEL);

me semble un peu dangereux (le jour ou tu vas vouloir changer)

[jobe]

OK merci j'avais pas fait gaffe pour le paramètre de retour !

Merci pour le kmalloc je vais changer...