an introduction to the linux kernel and device drives (ntu 2016.03)

Note: The Copyrights of the referenced materials and photos go to their original authors. As a result, this slide is for personal reference only.

For the contents created in this document, the Copyright belongs to William W.-Y. Liang. © 2005-2016 All Rights Reserved.

NTU CSIE Open Source System Software

2016.03.22

An Introduction to the Linux Kernel with Device Drivers

William W.-Y. Liang (梁文耀), Ph. D.

http://www.ntut.edu.tw/~wyliang

for 台大資工系開源系統軟體課程

hosted by Prof. Shih-Hao Hung



https://ceiba.ntu.edu.tw/course/0947ea/index.htm



https://www.csie.ntu.edu.tw/people/bio.php?PID=56





© 2016 William W.-Y. Liang, All Rights Reserved.

General-purpose Operating Systems

Characteristics

Development of applications can be logically separated from hardware

Complete software stacks and middleware can be created to support easy

development of complex and versatile applications.

Example:

Linux (with many Distributions), Android, Chrome OS, Firefox OS,

Brillo, uClinux, MacOS, iOS, Windows, etc.

Application development

System independent application development: General applications,

GUI/Window programming, Web programming

System dependent software development: System programming, Device

drivers, Protocol software

2 NTU OSSSP 2016: Linux Kernel


The Linux Operating System

Open source and free

Maintained by numerous volunteer experts and hackers

Robust, efficient, and reliable

Modular, configurable, and scalable

Tons of applications available

Suitable for application types from low-end embedded systems, mid-range consumer

products, personal computer, and up to the high performance supercomputers


https://en.wikipedia.org/wiki/Linux_kernel


Some References

Linux Kernel Wiki


Linux Kernel Source

git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git

Reference books for Beginners

Linux Device Driver, 3rd Edition, by Jonathan Corbet, Alessandro

Rubini and Greg Kroah-Hartman, O'Reilly (Also available online

https://lwn.net/Kernel/LDD3/)

Linux Kernel in a NutShell, by Greg Kroah-Hartman, O'Reilly (Also

available online http://www.kroah.com/lkn/)

Understanding the Linux Kernel, 3rd Edition, by Daniel P. Bovet, Marco

Cesati, O'Reilly



https://lwn.net/Kernel/LDD3/

http://www.kroah.com/lkn/


Chitchat about Linux and the Kernel


* Taiwanese slang :^)


A Systems View -- from Hardware to Software

Hardware

Software development environment

Tool chain and Library

Boot loader

OS Kernel / RTOS

Middleware*

Applications


* Example: In Android, the

middleware is called the

Application Framework.

Source: Qing Li and Caroline Yao, “real-time concepts for embedded systems”

Embedded System Development Environment Example


The Episode: System Booting

Source: Qing Li and Caroline Yao, “real-time concepts for embedded systems”



Boot Sequence Example


http://www.at91.com/linux4sam/bin/view/Linux4SAM/GettingStarted


Booting the Kernel – Before the C code



Booting the Kernel – Entering the C World



Prepare for Tracing the Kernel

Tools, always the most important thing

git, repo, vim, ctags, grep, find, etc.

Basics for understanding the Kernel

Data structures



Introduction to the Linux Kernel


Let’s try to understand the Linux

kernel by introducing the basics

for the device drivers and the

kernel features, and discussing

on some related issues.


Software View from User Program to Hardware

For a general purpose OS

such as Linux

User level (user space)

Coding

Compilation

Linking

Execution

Kernel (kernel space)

Program loading

System calls (API)

Device drivers

Hardware manipulation

Bare metal hardware



Device Drivers in Linux

Device drivers are usually treated as black boxes for

the application developers.

They resemble as a software layer

lying between the applications and

the actual devices.


http: //www.ni.com/tutorial/3789/en/


Device Drivers in Linux Kernel


ALESSANDRO RUBINI and JONATHAN CORBET, Linux Device Drivers, Second Edition


Major Classes of Devices for Linux

Character devices

A character (char) device is one that can be accessed as a stream

of bytes (just like a normal file).

Block devices

A block device is accessed in a unit of fixed-size block.

The device can be accessed randomly.

Network interfaces

Others: File Systems, Protocol Stack, USB, PCI, etc.

Refers to <kernel-source>/Documentation/devices.txt”



Device Files

File Operations vs. Device Accesses

Device Initialization vs. File Open

Device Accesses vs. File Read/Write

Device Control vs. File Control

Device Termination vs. File Close

UNIX/Linux systems implement device files to enable

users to employ familiar commands and functions such

as open, read, write, and close when working with

some peripherals.


int open( char *pathname, int flags, … );

int read( int fd, void *buf, size_t count );

int write( int fd, void *buf, size_t count );

int ioctl(struct inode *, struct file *, unsigned int, unsigned long );

int close( int fd );


How Device File and Driver Modules Work?


☼ Discussion: taking “Hello, World” as an example


Example: Applications using a Device



Device Number

Example crw-rw-rw- 1 root root 1, 3 Mar 2 2015 null

crw-rw-rw- 1 root root 1, 5 Mar 2 2015 zero

crw------- 1 root root 4, 1 Mar 2 2015 tty1

crw-rw-rw- 1 root tty 4, 64 Mar 2 2015 ttys0

crw-rw---- 1 root uucp 4, 65 Mar 2 2015 ttyS1

crw------- 1 root root 10, 1 Mar 2 2015 psaux

crw-rw-rw- 1 root root 123, 0 Mar 2 2015 androint

A System Administrator may create device files with the “mknod” command. For example,

mknod /dev/androint c 123 0

‘/dev/androint’ is the file’s pathname, ‘c’ indicates that it’s a character-mode device, 123 is its (unique) ‘major number’, and 0 is its ‘minor number’.


☼ Discussion: relationship between device files and drivers


Loadable Kernel Modules

A great mechanism for OS ‘extensibility’

No need to recompile and then reboot

A kernel module differs from a normal C program

A kernel module cannot call any of the familiar

functions from the standard C runtime libraries

A module will be run as part of the kernel

Any ‘bug’ can cause a system malfunction or a

complete crash!


☼ Discussion: GPL issues with the Linux kernel modules


Example


☼ Discussion: how multiple program entries work?


How to get a module to work in Kernel



Driver Functions


Example: Device Registration



Driver Methods -- File Operations

The kernel uses the file_operations structure to access the driver’s methods.

int (*open) (struct inode *, struct file *);

ssize_t (*read) (struct file *, char *, size_t, loff_t *);

ssize_t (*write) (struct file *, const char *, size_t, loff_t *);

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);

int (*release) (struct inode *, struct file *);

…


☼ Discussion: drivers vs. the object-orient concept


Kernel and User Space


☼ Discussion: address space for kernel and processes


Virtual to Physical Space


https://en.wikipedia.org/wiki/Operating_system

☼ Discussion: how the memory space is utilized?



Data Transfer between User and Kernel Space


Read: kernel->user

Write: user->kernel

☼ Discussion: issues for cross space data accesses

ALESSANDRO RUBINI and JONATHAN CORBET, Linux Device Drivers, Second Edition ,


Example: User & Kernel Space Data Transfer



Kernel Memory Allocation

Small size allocation

kmalloc and kfree dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);

memset(dptr->data, 0, qset * sizeof(char *));

Limitations

Large size allocation

vmalloc and vfree

Restrictions

Page allocation

Slab and memory pool


☼ Discussion: performance issues in memory management


Multi-tasking: the Central Part of the OS

Process states in OSes

Running: own CPU

Ready: To be scheduled,

in ready queue (run-queue)

Waiting:

Pending on I/O or Event

Delay itself for some duration

Request a resource but is not yet available

Linux Task States

Tasks: user-process, user-thread, kernel thread

States: TASK_RUNNING, TASK_INTERRUPTIBLE, etc.

Scheduling Policy

SCHED_OTHER, SCHED_FIFO, SCHED_RR, etc


☼ Discussion: scheduling and preemption issues


Concurrency Problems

Problems: Data inconsistency, Deadlock

Race Condition: Occurs when multiple tasks want to

access the shared resources, such as shared data or

hardware devices.


☼ Discussion: what’s the exact cause?


Thread Safe

Potential Causes of Thread-Unsafe Problems

Global variables

Static variables

Indirect accesses

Solutions

Reentrancy

Atomic operations

Thread-local storage

Mutual exclusion


Concurrency in Kernel and Device Drivers

Driver code vs. Tasks

Single Core vs. Multicore

IRQ impact

Soft-IRQ

☼ Discussion: performance issues for synchronizations


Synchronization Operations

Semaphore down(), up(), etc.

Mutex mutex_lock(), mutex_unlock(), etc.

Spin locks spin_lock(), spin_unlock(), etc.

Atomic operations

atomic_set(), atomic_add(), etc

Bit operations

set_bit(), clear_bit(), etc.


☼ Discussion: semaphore vs. spinlock, usage & performance


Interrupt Handling


☼ Discussion: cost and performance issues

of IRQ handling and solutions


Task Blocking and Waiting Queue

Processes are usually blocked due to I/O waiting.

No data available for read, or no space

available for write or device busy

Waiting queues

Blocked task is put into a waiting queue

before it is woke up.

36 NTU OSSSP 2016: Linux Kernel Linux Device Drivers, Second Edition

☼ Discussion: how it works?

Linux Device Drivers, Second Edition


The Endless Journey on Discovering Linux

To be Continued…

This brief introductory lecture is just a beginning.

Still many interesting things out there

Take it as interesting adventure, by learning from the

wonderful open source world!


https://en.wikipedia.org/wiki/Linux_kernel#/media/File:Linux_kernel_map.png

Let’s keep the discussion next week

on the next topic – Android Framework.

Note: The Copyrights of the referenced materials and photos go to their original authors. As a result, this slide is for personal reference only.

For the contents created in this document, the Copyright belongs to William W.-Y. Liang. © 2005-2016 All Rights Reserved.

Q & A

[email protected]


http://www.facebook.com/william.wyliang




