Chap 3.

The Buffer Cache

1. 2. 3. 4. 5. Buffer Headers Structure of the Buffer Pool Scenarios for Retrieval of a Buffer Reading and Writing Disk Blocks Advantages and Disadvantages of the Buffer Cache

2001.3.9

SS 1

Why Buffer cache

To reduce the frequency of Disk Access Slow disk access time
User level User program

libraries System call interface

File system
Kernel level

Buffer cache
block character Device driver

Process Control Subsystem

ipc schedular mm

Hardware control
Hardware level
2001.3.9

hardware
Figure 2.1 block diagram of the System Kernel
SS 1

Buffer Headers
Buffer
Memory array
Contains data from disk

Buffer header
Identifies the buffer Has
Device number Logical file system num not a physical device num Block number Pointer to a data array for the buffer

Memory array : Buffer header = 1 : 1

2001.3.9 SS 1

States of buffer
Locked Valid Delayed write Reading or writing Waiting for free
ptr to previous buf on hash queue ptr to previous buf on free list

Buffer header
Dev num Block num status
ptr to data area ptr to next buf on the hash queue ptr to next buf on free list

2001.3.9

Figure 3.1 buffer header

SS 1

Structure of the Buffer Pool

Free List
Doubly linked circular list Every buffer is put on the free list when boot When insert
Push the buffer in the head of the list ( error case ) Push the buffer in the tail of the list ( usually )

When take
Choose first element

Hash Queue
Separate queues : each Doubly linked list When insert
Hashed as a function device num, block num
2001.3.9 SS 1

Scenarios for Retrieval of a Buffer

To allocate a buffer for a disk block
Use getblk()
Has Five scenarios
algorithm getblk Input: file system number block number Output: locked buffer that can now be used for block { while(buffer not found) { if(block in hash queue){ /*scenario 5*/ if(buffer busy){ sleep(event buffer becomes free) continue; } mark buffer busy; /*scenario 1*/ remove buffer from free list; return buffer; }
2001.3.9

else{ if ( there are no buffers on free list) { /*scenario 4*/ sleep(event any buffer becomes free) continue; } remove buffer from free list; if(buffer marked for delayed write) { /*scenario 3*/ asynchronous write buffer to disk; continue; } /*scenario 2*/ remove buffer from old hash queue; put buffer onto new hash queue; return buffer; } }}
SS 1

1st Scenario
Block is in hash queue, not busy
Choose that buffer
Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98 3

4
5 50 35

64
97 10 99

Freelist header (a) Search for block 4 on first hash queue

2001.3.9

SS 1

1st Scenario
After allocating

Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98 3

4
5 50 35

64
97 10 99

Freelist header (b) Remove block 4 from free list

2001.3.9

SS 1

2nd Scenario
Not in the hash queue and exist free buff.
Choose one buffer in front of free list
Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98 3

4
5 50 35

64
97 10 99

Freelist header (a) Search for block 18 Not in the cache

2001.3.9

SS 1

2nd Scenario
After allocating

Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98

4
5 50 35

64
97 10 99 18

Freelist header (b) Remove first block from free list, assign to 18
2001.3.9 SS 1

3rd Scenario
Not in the hash queue and there exists delayed write buffer in the front of free list
Write delayed buffer async. and choose next
Blkno 0 mod 4 Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4 28 17 98 3 4 5 64 97 10 99

delay
50 35

delay

Freelist header
2001.3.9

(a) Search for block 18, delayed write blocks on free list

SS 1

3rd Scenario
After allocating
Blkno 0 mod 4 28 64

Blkno 1 mod 4
Blkno 2 mod 4 Blkno 3 mod 4

17
98 3

writing
50 35

97
10 99 18

writing

Freelist header (b) Writing block 3, 5, reassign 4 to 18

2001.3.9 SS 1

4th Scenario
Not in the hash queue and no free buffer
Wait until any buffer free and re-do
Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98 3

4
5 50 35

64
97 10 99

Freelist header (a) Search for block 18, empty free list

2001.3.9

SS 1

4th Scenario
Process A
Cannot find block b on the hash queue
No buffer on free list Sleep

Process B

Cannot find block b on hash queue

No buffers on free list Sleep

Somebody frees a buffer: brelse

Takes buffer from free list Assign to block b
2001.3.9

Figure 3.10 Race for free buffer

SS 1

4th Scenario
What to remind
When process release a buffer wake all process waiting any buffer cache

2001.3.9

SS 1

5th Scenario
Block is in hash queue, but busy
Wait until usable and re-do
Blkno 0 mod 4
Blkno 1 mod 4 Blkno 2 mod 4 Blkno 3 mod 4

28
17 98 3

4
5 50 35

64
97 10 99

busy

Freelist header (a) Search for block 99, block busy

2001.3.9

SS 1

5th Scenario
Process A
Allocate buffer to block b Lock buffer Initiate I/O Sleep until I/O done I/O done, wake up brelse(): wake up others Find block b on hash queue Buffer locked, sleep

Process B

Process C

Sleep waiting for any free buffer ( scenario 4 ) Get buffer previously assigned to block b reassign buffer to buffer b

Buffer does not contain block b start search again

time
2001.3.9 SS 1

Reading Disk Blocks

Use bread() If the disk block is in buffer cache
Return the data without disk access
Use getblk()

How to know the block is in buffer cache

Else

Calls disk driver to schedule a read request Sleep When I/O complete, disk controller interrupts the Process Disk interrupt handler awakens the sleeping process Now process can use wanted data
SS 1

2001.3.9

Reading Disk Blocks

algorithm
Algorithm bread Input: file system block number Output: buffer containing data { get buffer for block(algorithm getblk); if(buffer data valid) return buffer; initiate disk read; sleep(event disk read complete); return(buffer); }

2001.3.9

SS 1

Reading Disk Blocks

In linux
Block device file

block_read() block_write() bread() breada()

High-level block Device handler

getblk()

ll_rw_block()

RAM

Buffer cache

Low-level block Device handler

DISK

Figure 13-3 block device handler architecture for buffer I/O operation 2001.3.9 SS 1 in Understanding the Linux Kernel

Reading Disk Blocks

Read Ahead
Improving performance
Read additional block before request

Use breada()
Algorithm

2001.3.9

Algorithm breada Input: (1) file system block number for immediate read (2) file system block number for asynchronous read Output: buffer containing data for immediate read { if (first block not in cache){ get buffer for first block(algorithm getblk); if(buffer data not valid) initiate disk read; } SS 1

Reading disk Block

Algorithm-cont
if second block not in cache){ get buffer for second block(algorithm getblk); if(buffer data valid) release buffer(algorithm brelse); else initiate disk read; } if(first block was originally in cache) { read first block(algorithm bread) return buffer; } sleep(event first buffer contains valid data); return buffer; }

2001.3.9

SS 1

Writing disk Block

Synchronous write
the calling process goes the sleep awaiting I/O completion and releases the buffer when awakens.

Asynchronous write
the kernel starts the disk write. The kernel release the buffer when the I/O completes

Delayed write
The kernel put off the physical write to disk until buffer reallocated Look Scenario 3

Relese
Use brelse()

2001.3.9

SS 1

Writing Disk Block

algorithm
Algorithm bwrite Input: buffer Output: none { Initiate disk write; if (I/O synchronous){ sleep(event I/O complete); relese buffer(algorithm brelse); } else if (buffer marked for delayed write) mark buffer to put at head of free list; }

2001.3.9

SS 1

Release Disk Block

algorithm
Algorithm brelse Input: locked buffer Output: none { wakeup all process; event, waiting for any buffer to become free; wakeup all process; event, waiting for this buffer to become free; raise processor execution level to allow interrupts; if( buffer contents valid and buffer not old) enqueue buffer at end of free list; else enqueue buffer at beginning of free list lower processor execution level to allow interrupts; unlock(buffer); }
2001.3.9 SS 1

Advantages and Disadvantages

Advantages
Allows uniform disk access Eliminates the need for special alignment of user buffers
by copying data from user buffers to system buffers,

Reduce the amount of disk traffic

less disk access

Insure file system integrity

one disk block is in only one buffer

Disadvantages
Can be vulnerable to crashes
When delayed write

requires an extra data copy

When reading and writing to and from user processes

2001.3.9

SS 1

What happen to buffer until now

Allocated buffer Mark busy Using getblk() 5 scenarios Preserving integrity

manipulate
release

Using bread, breada, bwrite

Using brelse algorithm

2001.3.9

SS 1

Reference
LINUX KERNEL INTERNALS
Beck, Bohme, Dziadzka, Kunitz, Magnus, Verworner

The Design of the Unix operating system

Maurice j.bach

Understanding the LINUX KERNEL

Bovet, cesati

In linux
Buffer_head : include/linux/fs.h Bread : fs/buffer.c Brelse : include/linux/fs.h

2001.3.9

SS 1