Compreendendo loff_t * offp para operações de arquivo
Estou projetando um driver de dispositivo que simplesmente lê e grava em um buffer de caracteres. No entanto, minha pergunta é sobre as duas funções nofile_operations
estruturaread
ewrite
. Eu realmente não entendo o queloff_t *offp
é mesmo. Eu sei que para as operações de leitura e gravação que*offp
é o deslocamento do arquivo, ou seja, a posição atual de leitura / gravação do arquivo, no entanto, nem tenho certeza do que significa gravar ou ler de / para um arquivo de dispositiv
Pelo que reuni, e é assim que estou escrevendo e lendo no meu dispositivo é que eu crio uma estrutura que representa o meu dispositivo que eu chamomy_char_struct
que é mostrado abaix
struct my_char_structure{
struct cdev my_cdev;
struct semaphore sem;
char *data;
ssize_t data_size;
unsigned int access_key;
unsigned long size;
};
Esta é uma estrutura estática que é inicializada e apontada quando meu driver éinsmod
assim sendo
static dev_t dev_num;
static struct my_char_structure Dev;
int start_mod(void){
//Because we are dealing with a fictitious device, I want
//the driver to create my two devices with arbitrarily
//assigned major numbers.
struct my_char_structure *my_dev = &Dev;
int err;
alloc_chrdev_region(&dev_num, FIRST_MINOR, COUNT, DEVICE_NAME);
sema_init(&(my_dev->sem),1);
cdev_init(&(my_dev->my_cdev), &fops);
my_dev->my_cdev.owner = THIS_MODULE;
my_dev->my_cdev.ops = &fops;// fops is my file operations struct
err = cdev_add(&my_dev->my_cdev, dev_num, COUNT);
if(err<0)
printk(KERN_ALERT "There was an error %d.",err);
printk(KERN_ALERT " insmod to major number %d",MAJOR(dev_num));
return 0;
}
module_init(start_mod);
Quando meu dispositivo está aberto, apenas faço um ponteiro para o arquivo aberto para apontar para a estrutura estática que configurei durantemodule_init(start_mod)
assim sendo ..
int dev_open(struct inode *in_node, struct file *filp){
static struct my_char_structure *my_dev;
my_dev = container_of(in_node->i_cdev, struct my_char_structure, my_cdev);
printk(KERN_ALERT "The device number is %d",iminor(in_node));
if(!my_dev)
printk(KERN_ALERT "something didn't work. my_dev not initialized.");
filp->private_data = my_dev;
return 0;
}
O que meus métodos de leitura e gravação fazem é modificar a estrutura inicial Dev, que eu apontei com meus arquivos abertos. O que quer que eucopy_to_user
da minha estrutura é o que o usuário considera gravado no dispositivo e o que quer que eucopy_from_user
o usuário pensa que está escrevendo. Mas, além de alterar minha estrutura inicial Dev, a idéia de posição ou deslocamento do arquivo não faz sentido, a menos que se refira a um ponteiro para a memória buffer dentro do kernel para alguma estrutura ou tipo arbitrário. Essa é a única interpretação que tenho para o deslocamento do arquivo ... isso está correto? É isso que oloff_t *offp
aqui se refere a
write(struct file *filp, const char __user *buff, size_t count, loff_t *offp)
read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
(dado que meu entendimento está correto) Quando alguma operação de arquivo, como leitura / gravação, é chamada e eu não defini*offp
pessoalmente, o que é definido inicialmente como loff_t * offp?
Se no último arquivo_operação offp = some_arbitrary_address (porque eu disse isso), é isso que o offp seria definido quando essa operação for chamada novamente?
O que acontece se eu tiver outras operações de file_opens em execução, ela será definida como a última operação de file a deixou ou manterá uma guia da operação de file_open usada e substituirá * offp pelo que a file_open a tinh
O conceito de um dispositivo char é muito abstrato para mim quando parece que o próprio dispositivo nem armazena as informações como um arquivo deve, mas é o driver que salva as informações. Espero ter explicado minha nebulosidade e esclarecer qualquer coisa que pareça ambígua.