Block Device Drivers: - Naga Manjunath Senior S/W Engg in Bosch

Block Device Drivers
-Naga Manjunath Senior s\w Engg in Bosch
Linux Device Driver Architecture
Quick Functions Reference

#include <Linux/fs.h>
int register_blkdev(unsigned int major, const char *name); int unregister_blkdev(unsigned int major, const char *name); struct block_device_operations
#include <linux/genhd.h>
struct gendisk *alloc_disk(int minors); void add_disk(struct gendisk *gd); void set_capacity(struct gendisk *gd, setor_t sectors);
Quick Functions Reference

(cont)
#include <linux/fs.h>
struct block_device_operations
#include<linuix/genhd.h>
struct gendisk
#include <linux/blkdev.h>
struct request
struct gendisk
struct block_device_operations
Needed files:
sbull.c Makefile
Simple block device driver: sbull
Driver description:
it allocates 10 MB memory space to simulate a ramdisk which is like you insert a disk into the system the ramdisk has only one partition many file operations can be performed on it
mkfs, mount, umount, cp, ls, <
Simple block device driver: sbull (cont)

Needed functions:
sbull_init() sbull_exit() sbull_open() sbull_release() sbull_request() sbull_transfer()
Source code of sbull.c

#include #include #include #include #include #include #include #include <linux/init.h> <linux/module.h> <linux/kernel.h> <linux/fs.h> <linux/genhd.h> <linux/blkdev.h> <linux/vmalloc.h> <linux/hdreg.h>
include and define
#define KERNEL_SECTOR_SIZE 512
// define sector size is 512 in kernel
// HARDWARE define (ramdisksize = 20000*512 = 10M bytes) int nsectors = 20000; // number of sectors int hardsector_size = 512; // sector size = 512 bytes int dev_major_nr = 0; // system automatically allocate major number int SBULL_MINORS = 1; // MAX minor number is 1 ,ie.only one partition char dev_name[8] = "sbull"; MODULE_AUTHOR(MANJU"); MODULE_LICENSE("DualBSD/GPL");
Source code of sbull.c (cont)

struct sbull_dev { unsigned long size; unsigned char *data; spinlock_t lock; struct gendisk *gd; struct block_device *bdev; }Device;
struct and function prototype
static struct sbull_dev *dev = &Device; // function prototype static int sbull_open(struct inode *inode, struct file *filp); static int sbull_release(struct inode *inode, struct file *filp); static void sbull_transfer(struct sbull_dev *dev, unsigned long sector,unsigned long nsect, char *buffer, int write); static void sbull_request(request_queue_t *q);

static struct block_device_operations sbull_ops = { .owner = THIS_MODULE, .open = sbull_open, .release = sbull_release };
struct Device and open, release methods
static int sbull_open(struct inode *inode, struct file *filp) { printk("sbull_open(): do nothing...\n"); return 0; } static int sbull_release(struct inode *inode, struct file *filp) { printk("sbull_release(): do nothing...\n"); return 0; }

static int sbull_init(void) { printk("sbull_init(): initial sbull...\n"); // initial struct sbull_dev dev_major_nr = register_blkdev(dev_major_nr, dev_name); if (dev_major_nr <= 0) { printk("sbull_init(): unable to get major number\n"); return 0; } memset(dev, 0, sizeof(struct sbull_dev)); dev->size = nsectors * hardsector_size; dev->data = vmalloc(dev->size); if (dev->data == NULL) { printk("sbull_init(): vmalloc failure.\n"); return 0; } // initial spinlock spin_lock_init(&dev->lock);
sbull_init method

// initial gendisk struct *gd dev->gd = alloc_disk(SBULL_MINORS); if (!dev->gd) { printk("sbull_init(): allocate disk failure.\n"); return 0; } dev->gd->major = dev_major_nr; dev->gd->first_minor = 0; dev->gd->fops = &sbull_ops; // file operations pointer dev->gd->private_data= dev; // for private use strcpy(dev->gd->disk_name, "sbulla"); // device name is sbulla set_capacity(dev->gd, nsectors); // initial queue dev->gd->queue = blk_init_queue(sbull_request, &dev->lock); add_disk(dev->gd); return 0; }
sbull_init method: (cont)
sbull_request method
static void sbull_request(request_queue_t *q) { struct request *req; while((req = elv_next_request(q)) != NULL) { struct sbull_dev *dev = req->rq_disk->private_data; if( !blk_fs_request(req)) { If non-fs request here, end_request(req,0); do nothing } else { next sector to submit no. of sectors to submit sbull_transfer(dev, req->sector, req->current_nr_sectors, req->buffer, rq_data_dir(req)); end_request(req,1); } } decide the transfer dir. }

sbull_transfer method
static void sbull_transfer(struct sbull_dev *dev, unsigned long sector, unsigned long nsect, char *buffer, int write) { unsigned long offset = sector * KERNEL_SECTOR_SIZE; unsigned long nbytes = nsect * KERNEL_SECTOR_SIZE; if( (offset + nbytes) > dev->size ) { printk(KERN_NOTICE "beyond-end write (%ld %ld)\n", offset, nbytes); return; } if(write) memcpy(dev->data + offset, buffer, nbytes); else memcpy(buffer, dev->data + offset, nbytes); }

sbull_exit method and module-related macros
static void sbull_exit(void) { printk("sbull_exit(): exit sbull...\n"); del_gendisk(dev->gd); put_disk(dev->gd); unregister_blkdev(dev_major_nr, dev_name); vfree(dev->data); } module_init(sbull_init); module_exit(sbull_exit);
The Makefile of sbull

# Makefilefor sbull.c(kernel 2.6.x) # If KERNELRELEASE is defined, we've been invoked from the # kernel build system and can use its language. ifneq ($(KERNELRELEASE),) obj-m := sbull.o # Otherwise we were called directly from the command # line; invoke the kernel build system. else KDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) all: $(MAKE) -C $(KDIR) M=$(PWD) modules clean: rm rf *.o *.ko *.mod.c endif
LAB 1
Create the simple block device driver and insert into the kernel:
make sudo insmod sbull.ko cat /proc/devices | grep sbull
LAB 1 (cont)
Create the device node and mount it:
sudo mknod /dev/sbulla b XXX 0
replaces XXX to the major number you get above Ubuntu may create the /dev/sbulla for us
sudo mkfs.ext2 /dev/sbulla mkdir temp sudo mount /dev/sbulla temp df
LAB 1 (cont)
LAB 1 (cont)
Test the read and write abilities:
cd temp sudo mkdir HANEL cd .. sudo umount temp mkdir temp2 sudo mount /dev/sbulla temp2 ls temp2
LAB 1 (cont)
LAB 1 (cont)
Remove the sbull module from the kernel:
sudo umount temp2 sudo rmmod sbull
Ubuntu will also clear the /dev/sbulla for us
LAB 2
In this exercise, a extended version sbull will be introduced
it allocates 10 MB memory space to simulate a ramdisk which is like you insert a disk into the system the ramdisk has 2 partitions (partitionable) many file operations can be performed on it
mkfs, mount, umount, cp, ls, <
LAB 2 (cont)
In order to let the sbull able to be partitioned, there are something needed be done:
sets SBULL_MINORS to 2 adds new structure member short users in sbull_dev adds one new function in sbull_ops structure alters the sbull_open and sbull_release functions
LAB 2 (cont)
The structure method sbull_ioctl
int sbull_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { long size; struct hd_geometry geo; struct sbull_dev *dev = filp->private_data; switch(cmd) { case HDIO_GETGEO: size = dev->size; geo.cylinders= (size & ~0x3f) >> 6; geo.heads= 4; geo.sectors= 16; geo.start= 4; if (copy_to_user((void __user *) arg, &geo, sizeof(geo))) return -EFAULT; return 0; } return -ENOTTY; /* unknown command */
Provides the geometry information
LAB 2 (cont)
The functions sbull_open and sbull_release
static int sbull_open(struct inode *inode, struct file *filp) { struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data; filp->private_data= dev; spin_lock(&dev->lock); dev->users++; spin_unlock(&dev->lock); return 0; } static int sbull_release(struct inode *inode, struct file *filp) { struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data; spin_lock(&dev->lock); dev->users--; spin_unlock(&dev->lock); return 0; }
LAB 2 (cont)
Test the extended sbull modules:
make clean make sudo insmod sbull.ko sudo fdisk H 16 /dev/sbulla
LAB 2 (cont)
LAB 2 (cont)
Now we have two partitions in the sbull ramdisk Formats they by the following instructions: sudo mkfs.ext2 /dev/sbulla1 sudo mkfs.ext2 /dev/sbulla2 sudo mount /dev/sbulla1 temp sudo mount /dev/sbulla2 temp2 df
LAB 3
Please format the sbull in LAB1 by instruction: sudo mkfs.vfat F16 /dev/sbulla and observe what happened Try the same instruction executed on the sbulla in LAB2 Based on the LAB2, give me one block device with: 20MB and can be partitioned automatically: you can consult the sbull of LDD here
LAB 3 (cont)
LAB 3
There are two errors in the sbull of OReilly:
comment out the #include <linux/config.h> change the line 181
from end_that_request_last(req); to end_that_request_last(req, 1);
if you want to try that one, just type:

make sudo insmod sbull.ko ls al /dev/sbull*
Reference
Driver porting: a simple block driver Linux Device Drivers 3rd Edition Cross-Referencing Linux Linux Block Device Architecture

Block Device Drivers: - Naga Manjunath Senior S/W Engg in Bosch

Uploaded by

Copyright:

Available Formats

Block Device Drivers: - Naga Manjunath Senior S/W Engg in Bosch

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Block Device Drivers: - Naga Manjunath Senior S/W Engg in Bosch

Uploaded by

Copyright:

Available Formats

Block Device Drivers

-Naga Manjunath Senior s\w Engg in Bosch

Linux Device Driver Architecture

Quick Functions Reference

Quick Functions Reference

Simple block device driver: sbull

Simple block device driver: sbull (cont)

Source code of sbull.c

include and define

#define KERNEL_SECTOR_SIZE 512

// define sector size is 512 in kernel

Source code of sbull.c (cont)

struct and function prototype

Source code of sbull.c (cont)

struct Device and open, release methods

Source code of sbull.c (cont)

Source code of sbull.c (cont)

sbull_init method: (cont)

Source code of sbull.c (cont)

Source code of sbull.c (cont)

Source code of sbull.c (cont)

The Makefile of sbull

sudo mkfs.ext2 /dev/sbulla mkdir temp sudo mount /dev/sbulla temp df

The structure method sbull_ioctl

Provides the geometry information

if you want to try that one, just type:

You might also like