Unix ch03-03(2)
Download as PPT, PDF22 likes14,394 views
The document discusses the Linux kernel buffer cache. It describes the structure of buffer headers and the buffer pool. It outlines 5 scenarios for retrieving a buffer, including if the block is found in the hash queue, a free buffer is available, or if a delayed write buffer needs to be written first. It also covers reading and writing blocks to disk using functions like bread(), breada(), bwrite(), and brelse(). The advantages of the buffer cache in reducing disk access and ensuring integrity are presented.
Unix ch03-03(2)
- 1. Chap 3. The Buffer Cache 1. Buffer Headers 2. Structure of the Buffer Pool 3. Scenarios for Retrieval of a Buffer 4. Reading and Writing Disk Blocks 5. Advantages and Disadvantages of the Buffer Cache
- 2. Why Buffer cache To reduce the frequency of Disk Access Slow disk access time User program User level libraries System call interface File system Process ipc Kernel level Buffer cache Control schedular character block Subsystem mm Device driver Hardware control Hardware level hardware Figure 2.1 block diagram of the System Kernel
- 3. 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
- 4. States of buffer Locked Buffer header Buffer header Valid Delayed write Dev num Block num Reading or writing status Waiting for free ptr to data area ptr to previous buf on hash queue ptr to next buf on the hash queue ptr to previous buf on free list ptr to next buf on free list Figure 3.1 buffer header
- 5. 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
- 6. Scenarios for Retrieval of a Buffer To allocate a buffer for a disk block Use getblk() • Has Five scenarios algorithm getblk else{ Input: file system number if ( there are no buffers on free list) block number { /*scenario 4*/ Output: locked buffer sleep(event any buffer becomes free) that can now be used for block continue; { } while(buffer not found) remove buffer from free list; { if(buffer marked for delayed write) if(block in hash queue){ /*scenario 5*/ { /*scenario 3*/ if(buffer busy){ asynchronous write buffer to disk; sleep(event buffer becomes free) continue; continue; } } /*scenario 2*/ mark buffer busy; /*scenario 1*/ remove buffer from old hash queue; remove buffer from free list; put buffer onto new hash queue; return buffer; return buffer; } } }}
- 7. 1st Scenario Block is in hash queue, not busy Choose that buffer Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 Freelist header (a) Search for block 4 on first hash queue
- 8. 1st Scenario After allocating Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 Freelist header (b) Remove block 4 from free list
- 9. 2nd Scenario Not in the hash queue and exist free buff. Choose one buffer in front of free list Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 Freelist header (a) Search for block 18 – Not in the cache
- 10. 2nd Scenario After allocating Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 18 Blkno 3 mod 4 35 99 Freelist header (b) Remove first block from free list, assign to 18
- 11. 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 28 4 64 Blkno 1 mod 4 17 5 97 delay Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 delay Freelist header (a) Search for block 18, delayed write blocks on free list
- 12. 3rd Scenario After allocating Blkno 0 mod 4 28 64 Blkno 1 mod 4 17 5 97 writing Blkno 2 mod 4 98 50 10 18 Blkno 3 mod 4 3 35 99 writing Freelist header (b) Writing block 3, 5, reassign 4 to 18
- 13. 4th Scenario Not in the hash queue and no free buffer Wait until any buffer free and re-do Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 Freelist header (a) Search for block 18, empty free list
- 14. 4th Scenario Process A Process B Cannot find block b on the hash queue No buffer on free list Sleep 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 Figure 3.10 Race for free buffer
- 15. 4th Scenario What to remind When process release a buffer wake all process waiting any buffer cache
- 16. 5th Scenario Block is in hash queue, but busy Wait until usable and re-do Blkno 0 mod 4 28 4 64 Blkno 1 mod 4 17 5 97 Blkno 2 mod 4 98 50 10 Blkno 3 mod 4 3 35 99 busy Freelist header (a) Search for block 99, block busy
- 17. 5th Scenario Process A Process B Process C Allocate buffer to block b Find block b Lock buffer on hash queue Initiate I/O Buffer locked, sleep Sleep waiting for Sleep until I/O done any free buffer ( scenario 4 ) I/O done, wake up brelse(): wake up others Get buffer previously assigned to block b reassign buffer to buffer b’ Buffer does not contain block b start search again time
- 18. Reading Disk Blocks Use bread() If the disk block is in buffer cache How to know the block is in buffer cache • Use getblk() Return the data without disk access 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
- 19. Reading Disk Blocks algorithm algorithm Algorithm bread Algorithm bread Input: file system block number Input: file system block number Output: buffer containing data Output: buffer containing data {{ get buffer for block(algorithm getblk); get buffer for block(algorithm getblk); if(buffer data valid) if(buffer data valid) return buffer; return buffer; initiate disk read; initiate disk read; sleep(event disk read complete); sleep(event disk read complete); return(buffer); return(buffer); }}
- 20. Reading Disk Blocks In linux In linux Block device file Block device file High-level block High-level block block_read() Device handler Device handler block_write() bread() breada() getblk() ll_rw_block() Buffer cache Low-level block RAM Buffer cache Low-level block Device handler Device handler DISK Figure 13-3 block device handler architecture for buffer I/O operation in Understanding the Linux Kernel
- 21. Reading Disk Blocks Read Ahead Improving performance • Read additional block before request Use breada() Algorithm Algorithm Algorithm breada Algorithm breada Input: (1) file system block number for immediate read Input: (1) file system block number for immediate read (2) file system block number for asynchronous read (2) file system block number for asynchronous read Output: buffer containing data for immediate read Output: buffer containing data for immediate read {{ if (first block not in cache){ if (first block not in cache){ get buffer for first block(algorithm getblk); get buffer for first block(algorithm getblk); if(buffer data not valid) if(buffer data not valid) initiate disk read; initiate disk read; }}
- 22. Reading disk Block Algorithm-cont Algorithm-cont if second block not in cache){ if second block not in cache){ get buffer for second block(algorithm getblk); get buffer for second block(algorithm getblk); if(buffer data valid) if(buffer data valid) release buffer(algorithm brelse); release buffer(algorithm brelse); else else initiate disk read; initiate disk read; }} if(first block was originally in cache) if(first block was originally in cache) {{ read first block(algorithm bread) read first block(algorithm bread) return buffer; return buffer; }} sleep(event first buffer contains valid data); sleep(event first buffer contains valid data); return buffer; return buffer; }}
- 23. 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()
- 24. Writing Disk Block algorithm algorithm Algorithm bwrite Algorithm bwrite Input: buffer Input: buffer Output: none Output: none {{ Initiate disk write; Initiate disk write; if (I/O synchronous){ if (I/O synchronous){ sleep(event I/O complete); sleep(event I/O complete); relese buffer(algorithm brelse); relese buffer(algorithm brelse); }} else if (buffer marked for delayed write) else if (buffer marked for delayed write) mark buffer to put at head of free list; mark buffer to put at head of free list; }}
- 25. Release Disk Block algorithm algorithm Algorithm brelse Algorithm brelse Input: locked buffer Input: locked buffer Output: none Output: none {{ wakeup all process; event, wakeup all process; event, waiting for any buffer to become free; waiting for any buffer to become free; wakeup all process; event, wakeup all process; event, waiting for this buffer to become free; waiting for this buffer to become free; raise processor execution level to allow interrupts; raise processor execution level to allow interrupts; if( buffer contents valid and buffer not old) if( buffer contents valid and buffer not old) enqueue buffer at end of free list; enqueue buffer at end of free list; else else enqueue buffer at beginning of free list enqueue buffer at beginning of free list lower processor execution level to allow interrupts; lower processor execution level to allow interrupts; unlock(buffer); unlock(buffer); }}
- 26. 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
- 27. What happen to buffer until now Allocated buffer Using getblk() – 5 scenarios Mark busy Preserving integrity manipulate Using bread, breada, bwrite release Using brelse algorithm
- 28. 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