Impossible de comprendre le fonctionnement de read_proc dans le module de kernel Linux

Je suis en train de passer en revue l’exemple de module de kernel sur cette page

Le read_proc utilisé dans le programme est le suivant:

int fortune_read( char *page, char **start, off_t off, int count, int *eof, void *data ) { int len; if (off > 0) { *eof = 1; return 0; } /* Wrap-around */ if (next_fortune >= cookie_index) next_fortune = 0; len = sprintf(page, "%s\n", &cookie_pot[next_fortune]); next_fortune += len; return len; }

Quelqu’un peut-il expliquer pourquoi off est coché pour être supérieur à 0. En outre, quelqu’un peut-il expliquer quelle est l’importance des arguments off et count.

D’après ce que j’ai compris jusqu’à présent, nous devons écrire des données dans une page et définir eof lorsque les données sont terminées.

Merci.

off est la position dans le fichier à partir de laquelle les données doivent être lues. Cela ressemble à un jeu de fichier normal. Mais, dans le cas de proc_read, c’est quelque chose de différent. Par exemple, si vous appelez un appel de lecture sur le fichier proc pour lire 100 octets de données, off et count dans proc_read ressemblera à ceci:

dans le premier temps, off = 0, compte 100. Dites par exemple dans votre proc_read que vous n’avez renvoyé que 10 octets. Ensuite, le contrôle ne peut pas revenir à l’application utilisateur, votre proc_read sera appelé par le kernel à nouveau avec la valeur 10 et comptera pour 90. Encore une fois, si vous retournez 20 dans la procédure proc_read, vous devrez à nouveau appeler avec off 30, compte 70. Ainsi, vous serez appelé jusqu’à ce que le compte atteigne 0. Les données sont ensuite écrites dans le tampon utilisateur donné et l’appel de votre application read () est renvoyé.

Mais si vous ne disposez pas de cent octets de données et que vous souhaitez ne renvoyer que quelques octets, vous devez définir l’eof sur 1. La fonction read () est renvoyée immédiatement.

Pour commencer, le commentaire suivant explique mieux que moi.

  /* * How to be a proc read function * ------------------------------ * Prototype: * int f(char *buffer, char **start, off_t offset, * int count, int *peof, void *dat) * * Assume that the buffer is "count" bytes in size. * * If you know you have supplied all the data you * have, set *peof. * * You have three ways to return data: * 0) Leave *start = NULL. (This is the default.) * Put the data of the requested offset at that * offset within the buffer. Return the number (n) * of bytes there are from the beginning of the * buffer up to the last byte of data. If the * number of supplied bytes (= n - offset) is * greater than zero and you didn't signal eof * and the reader is prepared to take more data * you will be called again with the requested * offset advanced by the number of bytes * absorbed. This interface is useful for files * no larger than the buffer. * 1) Set *start = an unsigned long value less than * the buffer address but greater than zero. * Put the data of the requested offset at the * beginning of the buffer. Return the number of * bytes of data placed there. If this number is * greater than zero and you didn't signal eof * and the reader is prepared to take more data * you will be called again with the requested * offset advanced by *start. This interface is * useful when you have a large file consisting * of a series of blocks which you want to count * and return as wholes. * (Hack by [email protected]) * 2) Set *start = an address within the buffer. * Put the data of the requested offset at *start. * Return the number of bytes of data placed there. * If this number is greater than zero and you * didn't signal eof and the reader is prepared to * take more data you will be called again with the * requested offset advanced by the number of bytes * absorbed. */