Programmer avec Linux en mode utilisateur

#define __KERNEL__
#define MODULE
#include <linux/module.h>
#include <linux/version.h>
#include <linux/wrapper.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/param.h>
#include <linux/interrupt.h>
#include <linux/time.h>
#include <linux/timer.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define true 1
#define false 0

/* C'est le nom que nous choisissons pour notre périphérique. Nous l'utilisons
également comme préfixe sur des fonctions telles que les points d'entrée
apparaissant dans la structure file_operations. */
#define DEV_NAME "pp"
static int Major;


/* Ce sont des prototypes pour les résidents de la structure file_operations */
static ssize_t pp_read(struct file *, char *, size_t, loff_t *);
static ssize_t pp_write(struct file *, const char *, size_t, loff_t *);
static int pp_open(struct inode *, struct file *);
static int pp_close(struct inode *, struct file *);


/* C'est la structure file_operations. Comme la fonction init_module la
déclarera avec le noyau, le noyau connaîtra tous les points d'entrée
qu'elle contient. */
struct file_operations Fops = {
owner: THIS_MODULE,
read: pp_read,
write: pp_write,
open: pp_open,
release: pp_close,
};


/* La fonction pp_probe n'a aucun rôle ici mais nous rappelle qu'un pilote
'réel' peut avoir besoin de détecter des ressources matérielles. Ces
ressources pourraient plus tard être allouées dans  init_module. */
static int pp_probe(void){
return 0;
}


/* La fonction pp_read est un moignon mais au moins elle effectue un
printk, à des fins de traçage, lorsqu'elle est appelée. */
static ssize_t pp_read(struct file *file, char *buff, size_t ctr, loff_t *woof) {
printk(KERN_ALERT "\npp_read active.\n");
return 0; 
}


/* La fonction pp_write est un moignon mais au moins elle effectue un
printk, à des fins de traçage, lorsqu'elle est appelée. */
static ssize_t pp_write(struct file *file, const char *buff, size_t ctr, loff_t *woof) {
printk(KERN_ALERT "\npp_write active.\n");
return 0; 
}


/* La fonction pp_open effectue un pintk à des fins de traçage. */
static int pp_open(struct inode *inode, struct file *file) {
printk(KERN_ALERT "\nUne instance de %s a été ouverte.\n", DEV_NAME);
return 0;
}


/* La fonction pp_close effectue un printk à des fins de traçage. */
static int pp_close(struct inode *inode, struct file *file) {
printk(KERN_ALERT "\nUne instance de %s a été fermée.\n", DEV_NAME);
return 0;
}


/* Ensuite, nous verrons que comme cet init_module
* déclare la structure file_operations, le noyau connaîtra
les points d'entrée qu'elle contient
* retourne un numéro majeur
* appelle pp_probe pour rechercher des ressources matérielles
Si des ressources matérielles étaient trouvées, il faudrait les
allouer pour que ce pilote puisse les utiliser, probablement
dans la portée d'init_module. */
int init_module(void) {
Major = register_chrdev( 0, DEV_NAME, &amp;Fops);
if (Major lt; 0) {
printk("Déclaration impossible !\n");
return Major; 
}
if (pp_probe() < 0) {
unregister_chrdev(Major, DEV_NAME);
printk(KERN_ALERT "pp_probe() failure!\n");
return -1;
}
printk(KERN_ALERT "\nDéclaré %s, au numéro majeur = %d.\n\n", DEV_NAME, Major);
printk("Pour utiliser %s, vous devez créer un fichier de périphérique.\n", DEV_NAME);
printk("Si cela n'a pas déjà été fait, alors saisissez :\n");
printk(" mknod /dev/%s c %d 0\n\n", DEV_NAME, Major);
printk("Définissez également les permissions appropriées pour /dev/%s.\n\n", DEV_NAME);
return 0;
}


/* La fonction cleanup_module annule la déclaration du pilote et,
dans un pilote 'réel', libérerait toute ressource allouée par by
init_module. */
void cleanup_module(void) { 
int ret;
ret = unregister_chrdev(Major, DEV_NAME);
if (ret < 0)
printk(KERN_ALERT "\nProblème d'annulation de déclaration où ret = %d\n\n", ret);
else 
printk(KERN_ALERT "\nAnnulé la déclaration de %s, au numéro majeur = %d\n\n", DEV_NAME, Major);
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE "/dev/pp"

int main() {
int ddfd = 0;
int ret = 0;
ddfd = open(DEVICE, O_RDWR);
if (ddfd < 0) {
printf("\nOuverture de %s impossible.\n", DEVICE);
exit(-1);
}
printf("\nOuverture de %s réussie.\n", DEVICE);
ret = close(ddfd);
if (ret < 0) {
printf("\nFermeture de %s impossible.\n", DEVICE);
exit(-1);
}
printf("\nFermeture de %s réussie.\n", DEVICE);
exit(0);
}

/* Mémoire partagée sysV IPC - l'écriture dans la mémoire
partagée shrmem1_sysV.c est censée être utilisée avec
shrmem2_sysV :
démarrage de shrmem2_sysV en arrière-plan,
puis démarrage de shrmem1_sysV */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define MEM_SZ 4096

struct shared_use_st {
int writ_by_you;
char some_text[BUFSIZ];
};

int main() {
int run = 1;
void *shared_mem = (void *) 0;
struct shared_use_st *shared_stuff;
char buffer[BUFSIZ];
int shmid;

shmid = shmget( (key_t)1234, MEM_SZ, 0666 | IPC_CREAT);
if (shmid == -1) {
perror("shmget dans shrmem1_sysV impossible");
exit(EXIT_FAILURE);
}
shared_mem = shmat(shmid, (void *)0, 0);
if (shared_mem == (void *)-1) {
perror("shmat dans shrmem1_sysV impossible");
exit(EXIT_FAILURE);
}
printf("memory attached at %X\n", (int)shared_mem);
shared_stuff = (struct shared_use_st *)shared_mem;
while (run) {
while (shared_stuff->writ_by_you == 1) {
sleep(3);
printf("Attend le client ...\n");
}
printf("Saisissez du texte : ");
fgets(buffer, BUFSIZ, stdin);
strcpy(shared_stuff->some_text, buffer);
shared_stuff->writ_by_you = 1;
if (strncmp(buffer, "end", 3) == 0) {
run = 0;
}
}
if (shmdt(shared_mem) == -1) {
perror("shmdt dans shrmem1_sysV impossible");
 exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

/* Mémoire partagée sysV IPC - la lecture depuis la mémoire
partagée shrmem2_sysV.c est censée être utilisée avec
shrmem1_sysV :
démarrage de shrmem2_sysV en arrière-plan,
puis démarrage de shrmem1_sysV
*/
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define MEM_SZ 4096
struct shared_use_st {
int writ_by_you;
char some_text[BUFSIZ];
};
int main() {
int run = 1;
void *shared_mem = (void *) 0;
struct shared_use_st *shared_stuff;
int shmid;
shmid = shmget( (key_t)1234, MEM_SZ, 0666 | IPC_CREAT);
if (shmid == -1) {
perror("shmget dans shrmem2_sysV impossible ");
exit(EXIT_FAILURE);
}
shared_mem = shmat(shmid, (void *)0, 0);
if (shared_mem == (void *)-1) {
perror("shmat dans shrmem2_sysV impossible");
exit(EXIT_FAILURE);
}
printf("mémoire attachée à %X\n", (int)shared_mem);
shared_stuff = (struct shared_use_st *)shared_mem;
shared_stuff->writ_by_you == 0;
while (run) {
if (shared_stuff->writ_by_you == 1) {
printf("Vous avez écrit : %s", shared_stuff->some_text);
sleep(rand() % 4);
shared_stuff->writ_by_you = 0;
if (strncmp(shared_stuff->some_text, "end", 3) == 0) {
run = 0;
}
}
}
if (shmdt(shared_mem) == -1) {
perror("shmdt dans shrmem2_sysV impossible");
exit(EXIT_FAILURE);
}
if (shmctl(shmid, IPC_RMID, 0) == -1) {
perror("shmctl dans shrmem2_sysV impossible");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

/* Passage de messages sysV IPC  - l'expéditeur sendmsg_sysV.c
est censé fonctionner avec recvmsg_sysV :
démarrage de rcvmesg_sysV en arrière-plan,
puis démarrage de sendmsg_sysV
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define BUF 1024


struct my_msg_st {
long int my_msg_type;
char some_text[BUFSIZ];
};
int main() {
int run = 1;
struct my_msg_st some_data;
int msqid;
char buffer[BUF];
msqid = msgget( (key_t)1234, 0666 | IPC_CREAT);
if (msqid == -1) {
perror("msgget dans sendmsg_sysV impossible");
exit(EXIT_FAILURE);
}
while (run) {
printf("Saisissez du texte :");
fgets(buffer, BUF, stdin);
some_data.my_msg_type = 1;
strcpy(some_data.some_text, buffer);
if (msgsnd(msqid, &amp;some_data, BUF, 0) == -1) {
perror("msgsnd dans sendmsg_sysV impossible");
exit(EXIT_FAILURE);
}
if (strncmp(buffer, "fin", 3) == 0) {
run = 0;
}
}
exit(EXIT_SUCCESS);
}

/* Passage de messages sysV IPC  - le receveur recvmsg_sysV.c
est censé fonctionner avec sendmsg_sysV :
démarrage de recvmsg_sysV en arrière-plan,
puis démarrage de sendmsg_sysV */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct my_msg_st {
long int my_msg_type;
char some_text[BUFSIZ];
};

int main() {
int run = 1;
struct my_msg_st some_data;
int msqid;
long int msg_to_recv = 1;
msqid = msgget( (key_t)1234, 0666 | IPC_CREAT);
if (msqid == -1) {
perror("msgget dans recvmsg_sysV impossible");
exit(EXIT_FAILURE);
}
while (run) {
if (msgrcv(msqid, &amp;some_data, BUFSIZ, msg_to_recv, 0) == -1) {
perror("msgrcv dans recvmsg_sysV impossible");
exit(EXIT_FAILURE);
}
printf("Vous avez écrit : %s", some_data.some_text);
if (strncmp(some_data.some_text, "fin", 3) == 0) {
run = 0;
} 
}
if (msgctl(msqid, IPC_RMID, 0) == -1) {
perror("msgctl dans recvmsg_sysV impossible");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}