>>> Диск примонтирован? Может дисковый кэш. Что будет при команде sync?
>> Без разницы смонтирован диск или нет, на устройстве может вообще не быть
>> никакой ФС, так как вызов make_request_fn в данном случае лежит сразу
>> над драйвером физического устройства.
> Удалось разобраться ?

Нет, увы. Забросил.
А у вас тоже такая же проблема?

>>> Диск примонтирован? Может дисковый кэш. Что будет при команде sync?
>> Без разницы смонтирован диск или нет, на устройстве может вообще не быть
>> никакой ФС, так как вызов make_request_fn в данном случае лежит сразу
>> над драйвером физического устройства.
> Удалось разобраться ?

Сорри, поторопился я с ответом. Сейчас в код глянул, там вот такое. Насколько я помню, это работает и на запись и на чтение, но при большой нагрузке валит систему. Разбираться почему это происходит было, честно говоря уже лень. Если разберетесь, не забудьте поделиться :)

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#define PARTITION_NAME "/dev/sdb"

char *ptr;
int i;

struct block_device *bd;

make_request_fn *orig_mrqfn;

bio_end_io_t *old_endio;

// BIOs set
struct bio_set * bs;

// HOOKs
static struct kmem_cache *my_hooks;

// HOOK
struct hook{
    void *old_private;
    bio_end_io_t *old_endio;
    struct bio *clone;
};

// read bi_end_io

static void read_endio(struct bio *b, unsigned done, int error)
{

    printk(KERN_INFO "filter: my bio_endio err=%d size=%u sector=%lu vi_vcnt=%d",error,done,b->bi_sector,b->bi_vcnt);
    struct hook *hook = b->bi_private;
    
    b->bi_end_io = hook->old_endio;
    b->bi_private = hook->old_private;
    

    unsigned int count=0;

    printk(KERN_INFO " clone_size=%u clone_sector=%lu", hook->clone->bi_size, hook->clone->bi_sector );
    int segno=0;
    struct bio_vec *bvec;

    bio_for_each_segment(bvec,hook->clone,segno){

        char *buffer = __bio_kmap_atomic(hook->clone,segno, KM_USER0);    
        for(i=hook->clone->bi_io_vec[segno].bv_offset;i<hook->clone->bi_io_vec[segno].bv_len+hook->clone->bi_io_vec[segno].bv_offset;i++){
//            printk("%c",buffer[i]);
            buffer[i]=~buffer[i];
        }
        __bio_kunmap_atomic(buffer, KM_USER0);
        
    }
    
    
    //printk(KERN_INFO "filter: my bio_endio count=%d",count);

    kmem_cache_free(my_hooks,hook);

    b->bi_end_io(b,error);

};

// write bi_end_io - unused

static void write_endio(struct bio *b, unsigned done, int error){

    printk(KERN_INFO "filter: write_endio err=%d size=%u sector=%lu",error,done,b->bi_sector);

    b->bi_end_io(b,error);
}

// filter make_request_fn()
static void filter_mrqfn(struct request_queue *rq, struct bio *b)
{

    printk(KERN_INFO "filter: Sector=%lu Size=%d bi_rw=%lu rw_bit=%lu\n", b->bi_sector, b->bi_size, b->bi_rw, (b->bi_rw & 1));

    // direction WRITE
    if(bio_data_dir(b)==WRITE){
        printk(KERN_INFO "filter: write Sector=%lu Size=%d bi_rw=%lu rw_bit=%lu\n", b->bi_sector, b->bi_size, b->bi_rw, (b->bi_rw & 1));

        struct hook *hook=NULL;
        hook = kmem_cache_alloc(my_hooks,GFP_NOIO|__GFP_NOFAIL);

        *hook = (struct hook){
            .old_private = b->bi_private,
            .old_endio = b->bi_end_io,
            .clone = bio_clone_bioset(b,GFP_NOIO,bs),
        };
        b->bi_end_io = read_endio;
        b->bi_private = hook;

        ptr=(char *)bio_data(b);
        for(i=0;i<b->bi_size;i++)  //4096 as bio is going to be in 4kb chunk
        {
           //printk("%c",*ptr);
           ptr[i]=~ptr[i];    
        }

        /* calling the original make_request_fn() */
        orig_mrqfn(rq, b);

    }

    // direction READ
    if(bio_data_dir(b)==READ){

        //printk(KERN_INFO "filter: read Sector=%lu Size=%d bi_rw=%lu rw_bit=%lu\n", b->bi_sector, b->bi_size, b->bi_rw, (b->bi_rw & 1));
        
        struct hook *hook=NULL;
        hook = kmem_cache_alloc(my_hooks,GFP_NOIO|__GFP_NOFAIL);

        *hook = (struct hook){
            .old_private = b->bi_private,
            .old_endio = b->bi_end_io,
            .clone = bio_clone_bioset(b,GFP_NOIO,bs),
        };
        b->bi_end_io = read_endio;
        b->bi_private = hook;
        /* calling the original make_request_fn() */
        orig_mrqfn(rq, b);
    
    }
}

/*
* set_mrqfn() - Change the original make_request_fn() to our
* modules request function
*/

static void set_mrqfn(void)
{
    struct super_block *sb;
    /* lock filesystem to prevent any further changes */
    fsync_bdev(bd);
    sb = freeze_bdev(bd);
    if (bd->bd_disk->queue->make_request_fn == filter_mrqfn) {
        printk(KERN_INFO "filter: modules request function is already active\n");
    } else {
        /* save the pointer to the original make_request_fn() */
        orig_mrqfn = bd->bd_disk->queue->make_request_fn;
        /* replace the original with our modules request function */
        bd->bd_disk->queue->make_request_fn = filter_mrqfn;

    }
    
    /* unlock filesystem */
    thaw_bdev(bd, sb);
}

/*
* restore_mrqfn() - Restore the original make_request_fn()
*/

static void restore_mrqfn(void)
{
    struct super_block *sb = bd->bd_super;
    if (orig_mrqfn) {
        /* lock filesystem to prevent any further changes */
        fsync_bdev(bd);
        sb = freeze_bdev(bd);
        /* restore the original request function */
        bd->bd_disk->queue->make_request_fn = orig_mrqfn;
        /* unlock filesystem */
        thaw_bdev(bd, sb);
    }
    orig_mrqfn = NULL;
}

static int __init filter_init(void)
{
    printk(KERN_DEBUG "filter: %s\n", __FUNCTION__);    
    orig_mrqfn = NULL;
    // Read block device from path
    bd = blkdev_get_by_path(PARTITION_NAME, FMODE_READ, NULL);
    if (IS_ERR(bd)) {
        printk(KERN_ERR "filter: failed to get block device\n");
        return 0;
    }
    
    printk(KERN_INFO "filter: found block device with major number %d\n", bd->bd_disk->major);
    printk(KERN_INFO "filter: file system block size %d\n", bd->bd_block_size);
    printk(KERN_INFO "filter: start sector %lu\n", (unsigned long)bd->bd_part->start_sect);
    printk(KERN_INFO "filter: number of sectors %lu\n", (unsigned long)bd->bd_part->nr_sects);
    printk(KERN_INFO "filter: logical block size %d\n", bdev_logical_block_size(bd));
    printk(KERN_INFO "filter: physical block size %d\n", bdev_physical_block_size(bd));
    set_mrqfn();

    if(!(my_hooks = kmem_cache_create("my_hooks",sizeof(struct hook), __alignof__(struct hook),0 ,NULL))){
    return 1; // fail!!!
    };
    return 0;
}

static void __exit filter_exit(void)
{
    printk(KERN_DEBUG "filter: %s\n", __FUNCTION__);
    restore_mrqfn();
    // clear HOOKs
    if(my_hooks){
    kmem_cache_destroy(my_hooks);
    }

    if (!IS_ERR(bd)) {
        blkdev_put(bd, FMODE_READ);
    }
}

module_init(filter_init);
module_exit(filter_exit);
MODULE_LICENSE("Dual MIT/GPL");
MODULE_AUTHOR("VV");