Device controller and driver

driver Defn: a special kernel module that contrls the operations of a device with the device specific information controller Defn: a hardware unit on a device that can know and control a devices status or behaviour, which communicates with the CPU via a driver

Types of IO devices

character stream vs block
swqeuential vs random access
synchronous vs async
sharable or dedicated

OS provides a consistent interface for them in the /dev folder (unix systems). e.g., ramdisk device is name /dev/memdrv. each device has a file under /dev that can be handled with file operations read()/write()

block devices

commands (sent from device driver to device controller)

read block
write block
seek block (for random access block devices)

the sequence of read/write requests can (should) be optimized

character devices

commands
- get char
- put char

also support buffering (accepting keyboard input line by line) and editing of buffers (e.g., spcial treatement of backspace character)

IO models

IO system calls use different IO models

blocking - when a proccess needs IO input it waits to recieve it before continuing
non blocking - waits a fixed (small) amount of time, and returns (possibly with some data still untransferred)
async - does not wait, is informed with a signal when io is completed

IO scheduling and buffering

for when there are several requests for IO waiting to be serviced

first come firs served is not efficient

IO buffers are used in main memroy to optimise file systems

when a data block is used often, it is kept is memory and only written to secondary storage once all its accesses are finished

example ramdisk driver

open

int temp_open (struct inode *inode, struct file *filp){ 
	// check if the process has the permission to access; 
	// suspend the calling process if the device is busy 
	// or used by another process; 
	// otherwise record the id of the calling process 
	// so that the device is owned by the process; 
	// initialise or reset the device. 
}

read

ssize_t temp_read(struct file *filp, char __user *buf,size_t count,loff_t *f_pos){ 
	// find the location of data; 
	// ask the controller to copy data to kernel kbuf 
	// copy data to user space kbuf -> buf 
	copy_to_user (buf, kbuf, count); 
	*f_pos += count; // update pointer 
	return count; // return the number of bytes read 
}

write

ssize_t temp_write(struct file *filp, char __user *bufsize_t count, loff_t *f_pos){ 
	// copy data from user space buf -> kbuf 
	copy_from_user (kbuf, buf, count); 
	// find the location of data; 
	// ask the controller to copy data from kernel kbuf 
	*f_pos += count; // update pointer 
	return count; // return the number of bytes written 
}

close

int temp_release (struct inode *inode, struct file *filp){
	// release the device by removing the id of the process;
	// check if there is any waiting process to wake up;
	// undo anything done at open(), e.g. free memory. 
}

3.2 KiB Raw Blame History