static void iblock_bio_destructor(struct bio *bio)
{
struct se_cmd *cmd = bio->bi_private;
struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
bio_free(bio, ib_dev->ibd_bio_set);
}
static ssize_t __ext4_read_buff(struct super_block *sb, size_t offset, void *buff, size_t size)
{
ssize_t ret, start_blk;
struct bio *bio;
start_blk = offset / SECT_SIZE;
bio = bio_alloc();
if (!bio)
return -ENOMEM;
bio->size = (offset % SECT_SIZE + size + SECT_SIZE - 1) & ~(SECT_SIZE - 1);
bio->data = malloc(bio->size);
if (!bio->data) {
ret = -ENOMEM;
goto L1;
}
bio->bdev = sb->s_bdev;
bio->sect = start_blk;
submit_bio(READ, bio);
memcpy(buff, bio->data + offset % SECT_SIZE, size);
ret = size;
free(bio->data);
L1:
bio_free(bio);
return ret;
}
static void dm_bio_destructor(struct bio *bio)
{
unsigned region;
struct io *io;
retrieve_io_and_region_from_bio(bio, &io, ®ion);
bio_free(bio, io->client->bios);
}
static int ext4_check_fs_type(const char *bdev_name)
{
struct ext4_super_block *e4_sb;
struct bio *bio;
char buff[EXT4_SUPER_BLK_SIZE];
struct block_device *bdev;
uint32_t fc, frc, fi;
int ret;
bdev = bdev_get(bdev_name);
if (NULL == bdev) {
DPRINT("bdev %s not found!\n", bdev_name);
return -ENODEV;
}
bio = bio_alloc();
if (!bio)
return -ENOMEM;
bio->bdev = bdev;
bio->sect = 1024 / SECT_SIZE;
bio->size = sizeof(buff);
bio->data = buff;
submit_bio(READ, bio);
// TODO: check flags here
bio_free(bio);
e4_sb = (struct ext4_super_block *)buff;
if (0xEF53 != e4_sb->s_magic) {
DPRINT("%s is not \"ext4\" fs!\n", bdev_name);
return -EINVAL;
}
fc = e4_sb->s_feature_compat;
fi = e4_sb->s_feature_incompat;
frc = e4_sb->s_feature_ro_compat;
ret = ck_ext4_feature(fc, frc, fi);
#ifdef CONFIG_DEBUG
extern void ext_sb_list(struct ext4_super_block * esb);
if (ret == 0) {
ext_sb_list(e4_sb);
}
#endif
return ret;
}
int DoSplitIo(PVOLUME_EXTENSION VolumeExtension, ULONG io, PIRP upper_pirp, struct splitInfo *splitInfo,
long split_id, long split_total_id, long split_total_length, struct drbd_device *device, PVOID buffer, LARGE_INTEGER offset, ULONG length)
{
NTSTATUS status;
struct bio *bio;
unsigned int nr_pages;
nr_pages = (length + PAGE_SIZE - 1) >> PAGE_SHIFT;
bio = bio_alloc(GFP_NOIO, nr_pages, '75DW');
if (!bio)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
bio->split_id = split_id;
bio->split_total_id = split_total_id;
bio->split_total_length = split_total_length;
bio->splitInfo = splitInfo;
bio->bio_databuf = buffer;
bio->pMasterIrp = upper_pirp;
bio->bi_sector = offset.QuadPart >> 9;
bio->bi_bdev = VolumeExtension->dev;
bio->bi_rw |= (io == IRP_MJ_WRITE) ? WRITE : READ;
bio->bi_size = length;
// save original Master Irp's Stack Flags
bio->MasterIrpStackFlags = ((PIO_STACK_LOCATION)IoGetCurrentIrpStackLocation(upper_pirp))->Flags;
status = drbd_make_request(device->rq_queue, bio); // drbd local I/O entry point
if (STATUS_SUCCESS != status)
{
bio_free(bio);
status = STATUS_INSUFFICIENT_RESOURCES;
}
return status;
}
/*
* default destructor for a bio allocated with bio_alloc_bioset()
*/
static void bio_fs_destructor(struct bio *bio)
{
bio_free(bio, fs_bio_set);
}
static void dm_bio_destructor(struct bio *bio)
{
struct bio_set *bs = bio->bi_private;
bio_free(bio, bs);
}
static void _clone_destructor(struct bio *const bio)
{
struct iostash_bio *const io = bio->bi_private;
struct hdd_info *const hdd = io->hdd;
bio_free(bio, hdd->bs);
}
static void dm_bio_destructor(struct bio *bio)
{
bio_free(bio, dm_set);
}
static int ext4_fill_super(struct super_block *sb)
{
int ret;
int group_count;
unsigned int bpg; // blocks per groups
char buff[KB(1)];
struct ext4_sb_info *e4_sbi;
struct ext4_super_block *e4_sb;
struct ext4_group_desc *gdt;
struct bio *bio;
size_t off;
bio = bio_alloc();
if (!bio)
return -ENOMEM;
bio->bdev = sb->s_bdev;
bio->sect = 1024 / SECT_SIZE;
bio->size = sizeof(buff);
bio->data = buff;
submit_bio(READ, bio);
// TODO: check flags here
bio_free(bio);
if (ext4_check_fstype(buff, sizeof(struct ext4_super_block)) == false) {
GEN_DBG("Invalid EXT4 magic number!\n"); // ((struct ext4_super_block *)buff)->s_magic);
ret = -EINVAL;
goto L1;
}
e4_sbi = zalloc(sizeof(*e4_sbi));
if (!e4_sbi) {
ret = -ENOMEM;
goto L1;
}
#if 1 // fixme
e4_sb = &e4_sbi->e4_sb;
memcpy(e4_sb, buff, sizeof(*e4_sb));
#endif
sb->s_fs_info = e4_sbi;
sb->s_blocksize = 1024 << e4_sb->s_log_block_size;
bpg = e4_sb->s_blocks_per_group;
group_count = (e4_sb->s_blocks_count_lo + bpg - 1) / bpg;
DPRINT("super block information:\n"
"label = \"%s\", inode size = %d, block size = %d\n",
e4_sb->s_volume_name[0] ? e4_sb->s_volume_name : "<N/A>",
e4_sb->s_inode_size, sb->s_blocksize);
gdt = malloc(group_count * sizeof(struct ext4_group_desc));
if (NULL == gdt) {
ret = -ENOMEM;
goto L2;
}
e4_sbi->gdt = gdt;
off = (e4_sb->s_first_data_block + 1) * sb->s_blocksize;
__ext4_read_buff(sb, off, gdt, group_count * sizeof(struct ext4_group_desc));
DPRINT("group descrition:\n"
"block groups = %d, free blocks = %d, free inodes = %d\n",
group_count, gdt->bg_free_blocks_count_lo, gdt->bg_free_inodes_count_lo);
return 0;
L2:
free(e4_sbi);
L1:
return ret;
}
