Estoy diseñando un controlador de dispositivo que simplemente lee y escribe en un búfer de caracteres. Sin embargo, mi pregunta es sobre las dos funciones en lafile_operations estructuraread ywrite. Realmente no entiendo lo queloff_t *offp realmente es. Sé que tanto para las operaciones de lectura como de escritura que*offp es el desplazamiento del archivo que significa la posición actual de lectura / escritura del archivo, sin embargo, ni siquiera estoy seguro de lo que significa escribir o leer en / desde un archivo de dispositivo.

De lo que reuní, y así es como escribo y leo desde mi dispositivo es que creo una estructura que representa mi dispositivo que llamomy_char_struct que se muestra a continuación.

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 es una estructura estática que se inicializa y apunta cuando mi controlador esinsmod como tal

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);

Cuando mi dispositivo está abierto, solo hago un puntero para que el archivo esté abierto para apuntar a esa estructura estática que configuré durantemodule_init(start_mod) como tal ..

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;
}

Lo que hacen mis métodos de lectura y escritura es modificar esa estructura inicial Dev, que he señalado con mis archivos abiertos. Lo que sea que yocopy_to_user de mi estructura es lo que el usuario considera escrito en el dispositivo y lo que sea que yocopy_from_user el usuario cree que está escribiendo. Pero más allá de cambiar mi estructura inicial Dev, la idea de la posición o el desplazamiento del archivo no tiene sentido a menos que se refiera a un puntero a la memoria intermedia dentro del núcleo para alguna estructura o tipo arbitrario. Esa es la única interpretación que tengo para el desplazamiento del archivo ... ¿es correcto? ¿Es eso lo que laloff_t *offp aquí se refiere 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 mi comprensión es correcta) Cuando se llama a una operación de archivo como lectura / escritura y no había configurado*offp personalmente, ¿en qué se establece inicialmente loff_t * offp?

Si en la última operación_archivo offp = some_arbitrary_address (porque lo dije), ¿es eso a lo que se establecerá offp cuando se vuelva a llamar a esta operación?

¿Qué sucede si tengo otras operaciones file_opens en ejecución? ¿Se establecerá en la última operación file_operation o mantendrá una pestaña de la operación file_open que usó y reemplazará * offp por lo que file_open tenía?

El concepto de un dispositivo char es demasiado abstracto para mí cuando parece que el dispositivo en sí ni siquiera almacena la información como debería hacerlo un archivo, sino que es el controlador el que guarda la información. Espero haber explicado mi confusión y aclararé todo lo que parezca ambiguo.