Character Device Drivers in deep

Name: Character Device Drivers in deep
Rating: 4.1 (154 reviews)

Linux Kernel Programming - Character Device Drivers

Created byLinux Trainer

Last updated 10/2020

English

English [Auto],

What you'll learn

Write character device driver from scratch
Understand the various file operations provided by character driver

Course content

6 sections • 88 lectures • 4h 20m total length

Introduction to character device drivers3:36
Explore how a device driver integrates code parts—user space access and hardware communication—treats devices as files and uses character devices for byte-wise data with system calls like open and read.
List Character and Block Devices2:28
Steps in Registering a character driver0:41
Device Number = Major + Minor3:32
Learn how the name-based connection between a user application and the device file contrasts with major and minor numbers, where the major identifies the driver and the minor distinguishes devices.
How to choose a device number1:58
Major numbers are statically assigned and documented by government sources, showing used device numbers; the lecture contrasts static and dynamic assignment and explains how dynamic mode allocates the last number.
Data type for device number dev_t0:50
Example of MAJOR,MINOR,MKDEV macros3:27
/proc/devices file1:03
Explore the /proc/devices file to see the devices currently present on the system, including their major numbers and names. The content is shown in two sections.
Static Allocation of Device Numbers1:36
Example of static allocation of device numbers2:26
Explore the static allocation of device numbers for character device drivers, illustrating default values and how explicit IDs are assigned and verified within the system.
Test cases on Previous Example1:58
Explore test cases on a previous example within character device drivers. Examine arguments discussed in the caption to understand how the topic unfolds.
What happens if i try to register same major number1:39
Explore what happens when two character device drivers register the same major number, and why dynamic allocation prevents conflicts unlike static allocation.
What happens if i try to register same name1:36
Registering Maximum Minor Numbers3:27
Explain how one major number supports multiple minor numbers via the magic number, with 126 majors and minor numbers starting at zero or ten, illustrating registration and overflow.
What is Maximum Major Number3:02
Dynamic Allocation of Device Number0:48
Example of dynamic allocation of device number1:54
Calling alloc_chrdev_region in loop4:12
Manual Device Node Creation3:54
Automatic Device Node Creation - class_create4:02
Automatic Device Node Creation - device_create2:48
Explore automatic device node creation using device_create in character device drivers, covering major and minor numbers, device class creation, and clean removal of devices.
Example of automatic device node creation1:54
Quiz 1

Introduction1:46
Learn how to implement a Linux character device using struct file_operations with open, close, read, and write handlers, including owner, permissions, and translating user-space parameters to driver parameters.
Registering file_operations with Linux Kernel1:44
cdev_init vs cdev_alloc1:27
Compare cdev_init and cdev_alloc in character device drivers, showing how memory allocation and dynamic setup affect device activation and protection against module unload.
Linux Kernel Module example of file operations registrations - cdev_alloc3:14
Explore creating a Linux kernel module character device with cdev_alloc, registering with a major number, and handling open, read, and release.
Linux Kernel Module example of file operations registrations - cdev_init2:33
Pseudo Devices - /dev/null, /dev/zero, /dev/urandom4:25
Walkthrough of drivers/char/mem.c2:42
How many times open and release will be called in case of fork4:16
Explore how open and release calls behave in fork scenarios for character device drivers, highlighting that open and release may occur only once and how close is involved.
How many times open and release will be called in case of multiple processes1:27
Explore how many times open and release are invoked when multiple processes access character device drivers.
struct file3:14
Example of struct file2:27
struct inode3:12
Explore the inode structure and its file metadata. Understand size, blocks, block size, timestamps, and device numbers, and how stat reveals them and how major and minor numbers identify devices.
Example of struct inode2:33
Example of struct inode vs struct file3:28
Showcases how struct inode and struct file interact during file open and creation, and highlights behavior when a file exists, is created anew, or is deleted.
What happens when i print user space buffer in write function5:27
Accessing user space buffer in Kernel space2:26
Accessing a user space buffer from kernel space is discussed, highlighting security issues and the risks of copying from user space in character device drivers.
copy_from_user2:58
What happens when i pass NULL ptr in write system call1:19
copy_to_user1:41
put_user4:11
Explore how put_user in character device drivers handles 64-bit values, stores data, and manages timing with sleeps to illustrate concurrent device interactions.
get_user2:14
Explore get_user in character device drivers, showing how to retrieve device values and manage a global variable versus a local property as the latest values change.
Passing structure from user space to kernel space and vice versa2:47
Can i pass user variables on heap to kernel driver1:52
Passing structure with one member from stack and other in heap2:29
Examine why passing a structure with one member on the stack and the other in the heap fails in character device driver operations, and analyze practical implications.
Kernel utility to print dev_t - print_dev_t, format_dev_t3:53
Learn how kernel utilities print dev_t using print_dev_t and format_dev_t, extract major and minor numbers with macros, write to a buffer, and return the number of characters written.
Can i use strlen in kernel space4:14
strnlen_user2:30
Learn how strnlen_user checks the length of a null-terminated string from userspace by passing a userspace pointer and a maximum length, returning the size including the terminating null.
Solution to passing structure with one member in stack and other in heap3:16
Learn to pass a structure with a stack and a heap member by copying from user twice and using pointers to access both parts.
Problem in character driver when we read character by character2:33
Reveal a flaw in a character driver when reading data byte by byte. Improper buffer handling and copying to user space can repeat the first character rather than advancing.
Adding offset support in read and write implementation5:44
Updated logic to read/write bytes less than requested/available3:51
Adding lseek support2:17
Creating multiple device nodes3:52
Explore creating multiple character device nodes by allocating several device numbers, initializing each device in a loop, and ensuring each uses a separate buffer to prevent data sharing.
container_of macro3:32
Adding support for private data2:25
Learn how to add support for private data in a character device driver by initializing device messages, linking devices, and accessing the base address, service name, and file pointers.
What happens when i call write from user space4:26

Introduction3:54
Ioctl example - BLKGETSIZE3:13
Learn how ioctl BLKGETSIZE retrieves a block device size by returning the number of 512-byte blocks, so you can compute disk size.
Ioctl example - BLKGETSIZE641:16
Learn an ioctl example with BLKGETSIZE64 to obtain a block device size in bytes and sectors, and see how user space can issue device specific custom commands.
Ioctl driver method - unlocked_ioctl3:26
Adding three ioctls in kernel driver3:24
Symbolic names to ioctls commands1:58
Defining ioctl commands6:07
C Example of ioctl macros1:52
Macros to decode information from ioctl command1:59
Updated driver code using ioctl macros1:59
What should be the return value if unsupported command is sent from user space1:34
access_ok macro2:25
Explore how the access_ok macro validates user-space pointers in a character device driver, including when to verify addresses without data transfer and version-specific argument usage.
Updated driver code using access_ok macro2:32
Explore how to update character device driver code with the access_ok macro to validate userspace arguments, perform access checks, and safely manage addresses in kernel space.
Fail scenarios of access_ok2:23
What happens when we pass a different size in ioctl command2:41
Explore how ioctl command sizes affect data transfer in character device drivers, showing why mismatched argument sizes can yield incorrect data and how to ensure you pass the exact size.
compat_ioctl6:05
Issues when 32-bit process trying to perform ioctl command6:21
On a 64-bit machine, the unsigned long size changes, complicating ioctl handling for 32-bit processes. Map or redefine command numbers to match the actual command size.
Sending a signal from module to process3:39

How many times a device driver is being used by application2:34
Allow only one process to use the device file at a time4:59
Use open and release to ensure only one process can open the device at a time, avoiding concurrency issues.
Restricting access to a single user at a time5:59
Capabilities5:19
Explore how capabilities assign only the necessary privileges to processes, instead of full privileges, and how extended attributes store these capabilities to safeguard privileged operations.
Example of using capabilities - cap_dac_override3:15
Example of using capabilities - cap_sys_module3:14
Presents an example of using the cap_sys_module capability to load modules within character device drivers. Shows how this capability enables observing system interactions and managing module execution.
Example of using capabilities - cap_sys_admin2:55
Open Flags5:11
What happens if I don't call close and process terminates1:47

Requirements

Should be able to write/compile/load/unload Hello World Linux Kernel Modules

Description

Updated on Oct 10: Added Downloads section

What will you learn from this course?

Introduction to character drivers
What is device number and device file
Allocating device number - statically and dynamically
Creating device file - Manually(mknod) and automatically (udev)
Registering character device and its file operation with Kernel
Copying data from user space to kernel space and vice versa
Understanding the various structures - struct file and struct inode
Implementation of open, release, read, write, llseek, ioctl file operations
How to create multiple device nodes and add support for private data
Flow of write system call from kernel system call entry point to driver write file operations
Handling all the error cases in ioctl implementation
Sending a signal to user space from kernel space
Various access control mechanisms and capabilities
Misc Driver

API's covered in this course:

MAJOR
MINOR
MKDEV
register_chrdev_region
alloc_chrdev_region
class_create
device_create
class_destroy
device_destroy
unregister_chrdev_region
imajor
iminor
copy_from_user
copy_to_user
put_user
get_user
print_dev_t
format_dev_t
strnlen_user
container_of
access_ok

Commands used in this course:

mknod
udevadm monitor

Who this course is for:

Developers interested in learning Linux Kernel Programming

Character Device Drivers in deep

What you'll learn

Explore related topics

Course content

Introduction22 lectures • 53min

File Operations36 lectures • 1hr 48min

IOCTL18 lectures • 57min

Access Control and Capabilities9 lectures • 35min

Misc Driver2 lectures • 7min

Resources1 lecture • 1min

Requirements

Description

Who this course is for: