linux/kernel/blk_drv/ll_rw_blk.c/blk_dev_init()

struct request request[NR_REQUEST]; // 请求项数组队列 NR_REQUEST=32
void blk_dev_init(void) // 初始化请求项

int i;
for (i=0 ; i< NR_REQUEST ; i++)
request[i].dev = -1; // 表示该设备空闲
request[i].next = NULL;

// 请求队列中，请求项的结构 blk.c
struct request
int dev; /* -1 if no request */
int cmd; /* READ orc WRITE */ // READ(0) WRITE(1)
int errors; //操作时产生错误的次数
unsigned long sector; // 起始扇区
unsigned long nr_sectors; // 读/写扇区数
char * buffer; // 数据缓冲区
struct task_struct * waiting; // 任务等待请求完成操作的队列
struct buffer_head * bh; // 缓冲区头指针
struct request * next; // 指向下一请求项
;

linux/kernel/blk_drv/ll_rw_blk.c/ll_rw_block()

void ll_rw_block(int rw, struct buffer_head * bh) // 接口函数 检查参数 调用 make_request

unsigned int major; // 主设备号
if ((major=MAJOR(bh-> b_dev)) > = NR_BLK_DEV || // NR_BLK_DEV=7
!(blk_dev[major].request_fn))// 判断主设备号是否存在以及该设备的请求操作函数是否存在
printk("Trying to read nonexistent block-device\\n\\r");
return;

make_request(major,rw,bh);

// 数据缓冲块头指针定义 Fs.h 文件系统
struct buffer_head
char * b_data; /* pointer to data block (1024 bytes) */// 指针
unsigned long b_blocknr; /* block number */// 块号
unsigned short b_dev; /* device (0 = free) */ // 数据源的设备号
unsigned char b_uptodate; // 更新标志：表示数据是否已更新
unsigned char b_dirt; /* 0-clean,1-dirty */ // 修改标志：0：未修改，1：已修改
unsigned char b_count; /* users using this block */// 使用的用户数
unsigned char b_lock; /* 0 - ok, 1 -locked */ // 缓冲区是否被锁定
struct task_struct * b_wait; // 指向等待该缓冲区解锁的任务
struct buffer_head * b_prev; // hash 队列上前一块（这四个指针用于缓冲区管理）
struct buffer_head * b_next; // hash 队列上下一块
struct buffer_head * b_prev_free; // 空闲表上前一块
struct buffer_head * b_next_free; // 空闲表上下一块
;
// 块设备数组
struct blk_dev_struct blk_dev[NR_BLK_DEV] =
NULL, NULL ,/* no_dev */
NULL, NULL ,/* dev mem */
NULL, NULL ,/* dev fd */
NULL, NULL ,/* dev hd */
NULL, NULL ,/* dev ttyx */
NULL, NULL ,/* dev tty */
NULL, NULL/* dev lp */
;

struct task_struct// 调度程序头文件 sched.h 中
/* these are hardcoded - dont touch */
long state; /* -1 unrunnable, 0 runnable, > 0 stopped */
long counter;
long priority;
long signal;
struct sigaction sigaction[32];
long blocked; /* bitmap of masked signals */
/* various fields */
int exit_code;
unsigned long start_code,end_code,end_data,brk,start_stack;
long pid,pgrp,session,leader;
int groups[NGROUPS];
/*
* pointers to parent process, youngest child, younger sibling,
* older sibling, respectively.(p-> father can be replaced with
* p-> p_pptr-> pid)
*/
struct task_struct*p_pptr, *p_cptr, *p_ysptr, *p_osptr;
unsigned short uid,euid,suid;
unsigned short gid,egid,sgid;
unsigned long timeout,alarm;
long utime,stime,cutime,cstime,start_time;
struct rlimit rlim[RLIM_NLIMITS];
unsigned int flags; /* per process flags, defined below */
unsigned short used_math;
/* file system info */
int tty; /* -1 if no tty, so it must be signed */
unsigned short umask;
struct m_inode * pwd;
struct m_inode * root;
struct m_inode * executable;
struct m_inode * library;
unsigned long close_on_exec;
struct file * filp[NR_OPEN];
/* ldt for this task 0 - zero 1 - cs 2 - ds& ss */
struct desc_struct ldt[3];
/* tss for this task */
struct tss_struct tss;
;
struct blk_dev_struct
void (*request_fn)(void);
struct request * current_request;
;

linux/kernel/blk_drv/ll_rw_blk.c/ ll_rw_page()

struct task_struct * wait_for_request = NULL; // 用于请求数组不空闲时，进程的临时等待处 ll_rw_page
void ll_rw_page(int rw, int dev, int page, char * buffer)

struct request * req;
unsigned int major = MAJOR(dev);
// 检查参数
// 检查主设备号以及设备的请求操作函数是否存在
if (major > = NR_BLK_DEV || !(blk_dev[major].request_fn))
printk("Trying to read nonexistent block-device\\n\\r");
return;

// 检查参数命令是否是 READ 或者 WRITE
if (rw!=READ & & rw!=WRITE)
panic("Bad block dev command, must be R/W");
// 建立请求项
repeat:
req = request+NR_REQUEST; // 将指针指向队列尾部
while (--req > = request)
if (req-> dev< 0) // 表示该项空闲
break;
if (req < request)
sleep_on(& wait_for_request); // 睡眠，过会再查看请求队列
goto repeat;

// 向空闲请求项中填写请求信息, 并将其加入队列中
/* fill up the request-info, and add it to the queue */
req-> dev = dev; // 设备号
req-> cmd = rw; // 命令（READ/WRITE）
req-> errors = 0; // 读写操作错误计数
req-> sector = page< < 3; // 起始读扇区 swap_nr
req-> nr_sectors = 8; // 读写扇区数 8 块
req-> buffer = buffer; // 数据缓冲区
req-> waiting = current; // 当前进程进入该请求等待队列
req-> bh = NULL; // 无缓冲块头指针（不用高速缓冲）
req-> next = NULL; // 下一个请求项指针
current-> state = TASK_UNINTERRUPTIBLE; // 置为不可中断状态
add_request(major+blk_dev,req); // 将请求项加入队列中
schedule(); // 因为需要对交换设备读/写8个扇区，需要花较长时间，所以将当前进程进行睡眠等待

1. 检查参数。代码8~14行，如果设备主设备号不存在或者该设备的请求操作函数不存在，显示出错信息，退出；如果参数给出的命令既不是READ或WRITE，表示内核程序出错。
2. 建立请求项。代码16~24行，从请求数组中寻址空闲项（从后往前寻址），如果没有则睡眠等等。
3. 向空闲请求项中填写请求信息。向请求项中填写相关信息（代码27~35行），代码第36行，把当前进程置为不可中断睡眠状态，代码第37行，将请求项加入队列中，因为需要对交换设备读/写8个扇区，需要花较长时间，所以将当前进程进行睡眠等待。

struct task_struct
/* these are hardcoded - dont touch */
long state; /* -1 unrunnable, 0 runnable, > 0 stopped */
long counter;
long priority;
long signal;
struct sigaction sigaction[32];
long blocked; /* bitmap of masked signals */
/* various fields */
int exit_code;
unsigned long start_code,end_code,end_data,brk,start_stack;
long pid,pgrp,session,leader;
int groups[NGROUPS];
/*
* pointers to parent process, youngest child, younger sibling,
* older sibling, respectively.(p-> father can be replaced with
* p-> p_pptr-> pid)
*/
struct task_struct*p_pptr, *p_cptr, *p_ysptr, *p_osptr;
unsigned short uid,euid,suid;
unsigned short gid,egid,sgid;
unsigned long timeout,alarm;
long utime,stime,cutime,cstime,start_time;
struct rlimit rlim[RLIM_NLIMITS];
unsigned int flags; /* per process flags, defined below */
unsigned short used_math;
/* file system info */
int tty; /* -1 if no tty, so it must be signed */
unsigned short umask;
struct m_inode * pwd;
struct m_inode * root;
struct m_inode * executable;
struct m_inode * library;
unsigned long close_on_exec;
struct file * filp[NR_OPEN];
/* ldt for this task 0 - zero 1 - cs 2 - ds& ss */
struct desc_struct ldt[3];
/* tss for this task */
struct tss_struct tss;
;
void sleep_on(struct task_struct **p)

__sleep_on(p,TASK_UNINTERRUPTIBLE);

linux/kernel/blk_drv/ll_rw_blk.c

// 锁定指定缓冲块
static inline void lock_buffer(struct buffer_head * bh)

cli(); // 禁止中断
while (bh-> b_lock)// 如果缓冲区已被锁定则睡眠，直到缓冲区解锁
sleep_on(& bh-> b_wait);
bh-> b_lock=1; // 立刻锁定该缓冲区
sti(); // 开启中断

// 释放（解锁）锁定的缓冲区
static inline void unlock_buffer(struct buffer_head * bh)

if (!bh-> b_lock)// 该缓冲区没有被锁定
printk("ll_rw_block.c: buffer not locked\\n\\r");
bh-> b_lock = 0; // 解锁
wake_up(& bh-> b_wait); // 唤醒等待该缓冲区的任务

linux/kernel/blk_drv/ll_rw_blk.c

// 向链表中加入请求项
static void add_request(struct blk_dev_struct * dev, struct request * req) // dev:指定块设备结构指针；req:已经设置好的请求项

struct request * tmp;
req-> next = NULL; // 置空请求项中的下一请求项指针
cli(); // 关中断
if (req-> bh)
req-> bh-> b_dirt = 0; // 清缓冲区"脏"标志
if (!(tmp = dev-> current_request)) // 指定设备dev当前无请求项 =0：表示该设备没有请求项 本次是第一个请求项
dev-> current_request = req; // 将块设备当前请求指针直接指向该请求项
sti(); // 开中断
(dev-> request_fn)(); // 立即执行请求函数 硬盘是 do_hd_request()
return;

for ( ; tmp-> next ; tmp=tmp-> next) // 如果当前指定设备dev忙，有空闲请求项在处理，则将当前请求项插入请求链表中 for 循环中的判断语句用于把req所指请求项与请求队列中已有的请求项作比较，找出req插入该队列的正确位置（电梯调度算法）
if (!req-> bh)
if (tmp-> next-> bh)
break; // 读页优先
else
continue;
if ((IN_ORDER(tmp,req) ||
!IN_ORDER(tmp,tmp-> next)) & &
IN_ORDER(req,tmp-> next))
break;
/*
if (tmp > req & & req > tmp-> next) break;
elif (tmp < = tmp-> next& & req > tmp-> next ) break;
else continue;
*/

req-> next=tmp-> next;
tmp-> next=req;
sti();

// 创建请求项并插入请求队列
static void make_request(int major,int rw, struct buffer_head * bh) //主设备号；指定命令；存放数据的缓冲区头指针

struct request * req;
int rw_ahead;

/* WRITEA/READA is special case - it is not really needed, so if the */
/* buffer is locked, we just forget about it, else its a normal read */
if (rw_ahead = (rw == READA || rw == WRITEA))// rw_ahead 预读写标志 68行，放弃提前命令
if (bh-> b_lock) // 指定的缓冲区正在使用，已被上锁，放弃预读写请求
return;
if (rw == READA)
rw = READ;
else
rw = WRITE;

if (rw!=READ &

推荐阅读

• 

  魅族E3与E3C到底那个更好?听说E3C爆音严重,e3c预警机参数
• 

  如何查看以太网服务器的设置？ 以太网服务器怎么查看
• 

  嫁接方法和技术要点 嫁接方法和技术要点讲解视频
• 

  Win10无法登录微软账号怎么办？错误代码0x80190001
• 

  我喜欢樱桃用英语怎么读 樱桃用英语怎么读
• 

  拳参
• 

  笔记|栈和队列常见oj题
• 

  梦见车被撞翻 梦见车被撞翻了是什么意思
• 

  千万不要去补牙洞 补牙可以维持多久
• 

  怎样改掉孩子说脏话的毛病
• 

  米糠是什么东西
• 

  粤港市属于哪个省 粤港市属于什么省
• 

  放置与召唤神秘来客怎么过
• 

  新手上路怎么踩油门 新手上路如何控制油门
• 

  菲斯曼老式锅炉故障代码故障的3种处理方法
• 

  ls dyna有限元分析,lsdyna有限元分析及仿真 PDF-CSDN
• 

  聚星如何注册
• 

  郑州三全食品厂 郑州三全食品厂最新招聘信息
• 

  五脏六腑指的是什么 五脏六腑包括哪些
• 

  石川小百合是什么样的人 石川小百合个人资料简介

• CommandLinux 关机重启命令
• ubuntu 和 Linux 内核啥关系（）
• 微型计算机组成结构
• 概述
• CommandLinux 绑定 CPU 核 以及 htop 命令
• 内核模块实验奔跑吧Linux内核
• Java流处理之转换编码的转换流
• 别再说你不知道分布式事务了
• Java6对synchronized的优化-锁升级过程详细过程