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.