PDA

Visualizza la versione completa : linux misc driver & file_operations : chi è che gli passa i parametri


markzzz
19-05-2010, 00:10
salve,

sono alle prime armi con i misc driver linux (livello kernel).
ora, premetto che non sono un genio di queste cose (infatti le stò imparando), e non mi è molto chiara questa cosa :

quando creo un misc driver dichiaro la struttura dei suoi file operators e le relative funzioni da chiamare in base alle operazioni che vengono richiamate user-space.
per esempio :


static ssize_t my_write(struct file *file, const char __user * buf, size_t count, loff_t *ppos)

static struct file_operations my_fops = {
.owner = THIS_MODULE,
.read = my_read,
.open = my_open,
.release = my_close,
.write = my_write,
#if 0
.poll = my_poll,
.fasync = my_fasync,
#endif
};

quando a user space chiamo il driver (con una echo ciao>/dev/mio_modulo_caricato), passo da user-space a kernel-space e faccio la open su quel driver; poi in questo caso (essendo echo) la .write (chiamando, in questo caso, my_write); lavoro su di essa e poi chiudo il device. ma chi è che passa i miei dati user-space a quella funzione?

per esempio "buf" chi glielo passa? lo prende dallo stack kernel dati memorizzato al cambio di contesto (tipo quando si chiama una a_primitiva) ? o c'è una subroutine che si occupa di questo? o forse ho capito male il procedimento :confused:

saluti :ciauz:

markzzz
20-05-2010, 16:33
cambiamo la domanda (forse quella di prima è un pò troppo complicata).

supponiamo che io abbia il mio programma in c che mi apre il device driver in questo modo :


static int dev;
dev=open("/dev/strmod", O_RDWR);
if (dev==-1) {
perror("String Module Not Loaded");
return -1;
}

al momento dell'apertura :

1 - mi ritornerà un file descriptor per il device (dev)
2 - apre effettivamente il file/device (caricandolo in memoria);
3 - essendo un device, agirà sulla struct file_operations (invocando le funzioni che ho implementato io nel mio device).

dico giusto fin quì?

ora, la mia funzione per esempio è :


static int my_open(struct inode *inode, struct file *file) {
//printk("String Device Opened %d\n", 2);

int *count;

count = kmalloc(sizeof(int), GFP_USER);
if (count == NULL) {
return -1;
}

*count = 0;
file->private_data = count;

return 0;
}

chi gli passa quei valori di *inode e *file? se li prende "da solo" ?

ri-saluti :)

Loading