标签：dea nts put node 命令 操作 移位 文件操作 keyboard
本文自顶向下一步步探索字符设备的读写是怎么完成的。通常我们在Linux应用程序中用open、read、write对各种类型的文件进行操作。我们可以从键盘输入，然后命令行窗口会显示你的输入，有输出的话则命令行窗口会显示输出。为什么所有的设备在Linux中都被看成是一个个文件，可以通过统一的read、write直接进行读写？文件句柄与终端设备有什么关联？为什么Linux允许多个控制终端登录？tty又是什么东西？读写时将发生哪些硬件中断，驱动程序是怎么回事？微型计算机原理与接口技术中的串口在Linux是怎么用的？对于这些疑问，本文将通过Linux 0.11版本的源码找到解答！
在fs/open.c(p310，第138行)中，给出了sys_open这个系统调用的具体实现
int sys_open(const char *filename,int flag,int mode)
{
struct m_inode * inode;
struct file * f;
int i,fd;
mode &= 0777 &~current->umask;
for(fd=0 ; fd<NR_OPEN ; fd++)
if(!current->filp[fd])
break;
if (fd>=NR_OPEN)
return -EINVAL;
current->close_on_exec&= ~(1<<fd);
f=0+file_table;
for (i=0 ; i<NR_FILE ; i++,f++)
if (!f->f_count)break;
if (i>=NR_FILE)
return -EINVAL;
(current->filp[fd]=f)->f_count++;
if((i=open_namei(filename,flag,mode,&inode))<0)
{
current->filp[fd]=NULL;
f->f_count=0;
return i;
}
/* ttys are somewhatspecial (ttyxx major==4, tty major==5) */
if(S_ISCHR(inode->i_mode))
{
if(MAJOR(inode->i_zone[0])==4)
{
if(current->leader && current->tty<0)
{
current->tty= MINOR(inode->i_zone[0]);
tty_table[current->tty].pgrp= current->pgrp;
}
}
else if(MAJOR(inode->i_zone[0])==5)
if(current->tty<0)
{
iput(inode);
current->filp[fd]=NULL;
f->f_count=0;
return -EPERM;
}
}
/* Likewise withblock-devices: check for floppy_change */
if(S_ISBLK(inode->i_mode))
check_disk_change(inode->i_zone[0]);
f->f_mode =inode->i_mode;
f->f_flags = flag;
f->f_count = 1;
f->f_inode = inode;
f->f_pos = 0;
return (fd);
}
sys_open首先查看当前进程的文件指针数组（NR_OPEN=20，include/linux/fs.h，p395，第43行），看是否有未使用的文件句柄fd，然后将句柄设置为在加载新的程序文件时不关闭，即可以在两个进程共享。
接着遍历全局文件结构表file_table（NR_FILE=64，include/linux/fs.h，p395，第45行），检查占用次数是否为零（因为file_table已经在内核的数据区中，不用再申请空间，这里检查的是count是否为零，而不是是否为NULL，task_struct是指针数组，检查该项是否为NULL确定是否被占用），找到后用当前句柄对其进行关联，引用计数加一（最后是一）。然后使用open_namei找到该打开文件的inode。对于字符设备文件，如果是串口设备且是在没有控制终端的会话领导进程打开，则设置当前进程的控制终端为串口次设备号（主串口或者辅串口），串口的前台进程组为当前的进程的进程组号。如果要打开控制台（键盘和显示屏），但当前进程没有控制终端(current->tty=-1)，则不能打开控制终端设备文件。另外该函数还能处理块设备文件。最后关联文件指针和inode节点，返回文件句柄（其实就是当前进程文件指针数组的下标）。
从这里可以看出，一个进程最多可以打开20个文件，而一个系统最多可以打开64个文件，每个进程的每一个文件指针都要消耗全局进程表的一项。一个设备文件节点的核心之处在于inode->i_zone[0]，也就是字符设备号。内核通过设备号定位具体的设备，对该设备进行读写。
在fs/read_write.c中(p304,第55行)实现了sys_read和sys_write两个系统调用：
int sys_read(unsigned int fd,char * buf,int count)
{
struct file * file;
struct m_inode * inode;
if (fd>=NR_OPEN ||count<0 || !(file=current->filp[fd]))
return -EINVAL;
if (!count)
return 0;
verify_area(buf,count);
inode = file->f_inode;
if (inode->i_pipe)
return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
if(S_ISCHR(inode->i_mode))
return rw_char(READ,inode->i_zone[0],buf,count,&file->f_pos);
if(S_ISBLK(inode->i_mode))
return block_read(inode->i_zone[0],&file->f_pos,buf,count);
if (S_ISDIR(inode->i_mode)|| S_ISREG(inode->i_mode))
{
if (count+file->f_pos> inode->i_size)
count =inode->i_size - file->f_pos;
if (count<=0)
return 0;
return file_read(inode,file,buf,count);
}
printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
return -EINVAL;
}
int sys_write(unsigned int fd,char * buf,int count)
{
struct file * file;
struct m_inode * inode;
if (fd>=NR_OPEN ||count <0 || !(file=current->filp[fd]))
return -EINVAL;
if (!count)
return 0;
inode=file->f_inode;
if (inode->i_pipe)
return (file->f_mode&2)?write_pipe(inode,buf,count):-EIO;
if(S_ISCHR(inode->i_mode))
return rw_char(WRITE,inode->i_zone[0],buf,count,&file->f_pos);
if(S_ISBLK(inode->i_mode))
return block_write(inode->i_zone[0],&file->f_pos,buf,count);
if(S_ISREG(inode->i_mode))
return file_write(inode,file,buf,count);
printk("(Write)inode->i_mode=%06o\n\r",inode->i_mode);
return -EINVAL;
}
首先利用fd获得当前进程的file指针，然后获得对应的inode。文件类型有字符设备文件、块设备文件、目录文件、普通文件和匿名管道，这里根据inode->i_mode进行确定，然后调用具体的文件操作函数。所以辨别文件类型是通过inode->i_mode，而却像一个大文件一样读写（拥有文件读取位置）。这也就是为什么所有的文件都可以用read和write来读写，且只需传递fd即可。将字符设备号（保存在字符设备节点inode->i_zone[0]）传递给rw_char函数，而一个文件指针的作用仅是保存文件的当前位置(file->f_pos)。值得注意的是文件的当前位置对字符设备来说没有作用。
rw_char位于fs/char_dev.c（p303，第95行）中：
int rw_char(int rw,int dev,char * buf, int count, off_t * pos)
{
crw_ptr call_addr;
if (MAJOR(dev)>=NRDEVS)
return -ENODEV;
if(!(call_addr=crw_table[MAJOR(dev)]))
return -ENODEV;
return call_addr(rw,MINOR(dev),buf,count,pos);
}
而crw_ptr是一个函数指针数组：
typedef int (*crw_ptr)(intrw,unsigned minor,char * buf,int count,off_t * pos);
static crw_ptr crw_table[]=
{
NULL, /* nodev */
rw_memory, /* /dev/mem etc */
NULL, /* /dev/fd */
NULL, /* /dev/hd */
rw_ttyx, /* /dev/ttyx */
rw_tty, /* /dev/tty */
NULL, /* /dev/lp */
NULL
}; /* unnamed pipes */
上述函数以主设备号为数组下标，将次设备号作为参数，调用对应的设备函数。注意一种设备只有一个主设备号，而同一种设备数量可以有多个，对应的便是多个次设备号。上述串口主设备号是4，调用的函数是rw_ttyx。控制终端的主设备号是5，调用的函数是rw_tty。
这两个函数在也在文件fs/char_dev.c（p301，第21行）中：
static int rw_ttyx(int rw,unsigned minor,char * buf,int count,off_t * pos)
{
return ((rw==READ)?tty_read(minor,buf,count) : tty_write(minor,buf,count));
}
static int rw_tty(int rw,unsigned minor,char * buf,int count, off_t * pos)
{
if (current->tty<0)
return -EPERM;
return rw_ttyx(rw,current->tty,buf,count,pos);
}
从上面可以看出不管是串口还是控制台终端，实际调用的函数是tty_read和tty_write，传递的都是次设备号，且文件位置pos不起作用。只不过控制台终端要求进程必须有控制终端，传进来的minor次设备号被忽略，使用当前进程的控制终端代替（current->tty）。注意rw_char操作的是设备号，而不是inode。
这两个函数位于linux/kernel/chr_drv/tty_io.c（p216，第230行）中：
int tty_read(unsigned channel,char * buf, int nr)
{
struct tty_struct * tty;
char c, * b=buf;
int minimum,time,flag=0;
long oldalarm;
if (channel>2 || nr<0)return -1;
tty = &tty_table[channel];
oldalarm = current->alarm;
time =10L*tty->termios.c_cc[VTIME];
minimum =tty->termios.c_cc[VMIN];
if (time && !minimum)
{
minimum=1;
if ((flag=(!oldalarm ||time+jiffies<oldalarm)))
current->alarm =time+jiffies;
}
if (minimum>nr)
minimum=nr;
while (nr>0)
{
if (flag &&(current->signal & ALRMMASK))
{
current->signal &=~ALRMMASK;
break;
}
if (current->signal)
break;
if (EMPTY(tty->secondary)|| (L_CANON(tty) &&
!tty->secondary.data &&LEFT(tty->secondary)>20))
{
sleep_if_empty(&tty->secondary);
continue;
}
do
{
GETCH(tty->secondary,c);
if (c==EOF_CHAR(tty) ||c==10)
tty->secondary.data--;
if (c==EOF_CHAR(tty) &&L_CANON(tty))
return (b-buf);
else
{
put_fs_byte(c,b++);
if (!--nr)
break;
}
}while (nr>0 &&!EMPTY(tty->secondary));
if (time &&!L_CANON(tty))
{
if ((flag=(!oldalarm ||time+jiffies<oldalarm)))
current->alarm =time+jiffies;
else
current->alarm =oldalarm;
}
if (L_CANON(tty))
{
if(b-buf)
break;
}
else if (b-buf >= minimum)
break;
}
current->alarm = oldalarm;
if (current->signal &&!(b-buf))
return -EINTR;
return (b-buf);
}
int tty_write(unsigned channel, char * buf, int nr)
{
static int cr_flag=0;
struct tty_struct * tty;
char c, *b=buf;
if (channel>2 || nr<0)return -1;
tty = channel + tty_table;
while (nr>0)
{
sleep_if_full(&tty->write_q);
if (current->signal)
break;
while (nr>0 &&!FULL(tty->write_q))
{
c=get_fs_byte(b);
if (O_POST(tty))
{
if (c==‘\r‘ &&O_CRNL(tty))
c=‘\n‘;
else if (c==‘\n‘ &&O_NLRET(tty))
c=‘\r‘;
if (c==‘\n‘ &&!cr_flag && O_NLCR(tty))
{
cr_flag = 1;
PUTCH(13,tty->write_q);
continue;
}
if (O_LCUC(tty))
c=toupper(c);
}
b++;
nr--;
cr_flag = 0;
PUTCH(c,tty->write_q);
}
tty->write(tty);
if (nr>0)
schedule();
}
return (b-buf);
}
从上面可知，传递过来的次设备号被用来索引tty_table这个数组，进而获得对应的tty设备的内核数据结构。对于tty_read，从tty->secondary获取数据，写到用户态的buf中，当tty->secondary队列为空，或者没有EOF和换行符且字符太少时，当前进程都会进入可中断的休眠状态；对于tty_write，从用户态的buf写数据到tty->write_q，并调用tty->write(tty)，表示将数据立即显示或者提醒串口输出数据。
tty_table这个数组已经占用了内核的数据段内存，内核中有很多已经定义好的固定长度的数组，如request数组，inode数组等。tty_table定义在kernel/chr_drv/tty_io.c(p217，第51行)中：
struct tty_struct tty_table[]=
{
{
{
ICRNL, /* change incomingCR to NL */
OPOST|ONLCR, /* changeoutgoing NL to CRNL */
0,
ISIG |ICANON | ECHO| ECHOCTL | ECHOKE,
0, /* console termio */
INIT_C_CC
},
0, /* initial pgrp */
0, /* initial stopped */
con_write,
{0,0,0,0,""}, /*console read-queue */
{0,0,0,0,""}, /*console write-queue */
{0,0,0,0,""} /*console secondary queue */
},{
{
0, /* no translation */
0, /* no translation */
B2400 | CS8,
0,
0,
INIT_C_CC
},
0,
0,
rs_write,
{0x3f8,0,0,0,""}, /*rs 1 */
{0x3f8,0,0,0,""},
{0,0,0,0,""}
},{
{
0, /* no translation */
0, /* no translation */
B2400 | CS8,
0,
0,
INIT_C_CC
},
0,
0,
rs_write,
{0x2f8,0,0,0,""}, /*rs 2 */
{0x2f8,0,0,0,""},
{0,0,0,0,""}
}
};
每个tty设备占用一项tty_struct，上面第一项是控制台（键盘和显示屏），第二项是主串口（com1），第三项是辅串口（com2）。
tty_struct定义在include/linux/tty.h（p409，第45行）：
struct tty_struct
{
struct termios termios;
int pgrp;
int stopped;
void (*write)(structtty_struct * tty);
struct tty_queue read_q;
struct tty_queue write_q;
struct tty_queue secondary;
};
其中termios位于include/termios.h（p374，第53行）
#define NCCS 17
struct termios
{
unsigned long c_iflag; /*input mode flags */
unsigned long c_oflag; /*output mode flags */
unsigned long c_cflag; /*control mode flags */
unsigned long c_lflag; /*local mode flags */
unsigned char c_line; /*line discipline */
unsigned char c_cc[NCCS]; /*control characters */
};
这里主要存放字符设备的标志，且每个标志占用一个比特，这些标志将影响对读入数据的解释。尤其要注意的是本地模式标志，设置ICANON可以启用规范模式。
pgrp是一个前台进程组号，而write是一个函数指针。tty_write函数每次将用户态的数据写往write_q，并调用tty->write(tty)。对于控制台，这个函数是con_write，取走write_q中的数据到显存里，在显示屏显示。对于串口，这个函数是rs_write，提醒串口有数据可以写了，等待写到数据口发送出去。这里有点类似面向对象中的多态。
tty_queue（在p409，第14行）是个存放数据的循环队列。
#define TTY_BUF_SIZE 1024
struct tty_queue
{
unsigned long data;
unsigned long head;
unsigned long tail;
struct task_struct *proc_list;
char buf[TTY_BUF_SIZE];
};
read_q是由中断程序操作的。串口或者键盘有数据到达时，就会有产生中断，然后保存到read_q中。read_q中的数据是原始数据，中断时还会调用copy_to_cooked，将其做进一步的处理，并将处理过的数据保存在secondary辅助队列中。从上面tty_read中可以看到tty_read读取的实际是secondary队列中的数据，也就是经过处理的数据。另外，从上面tty_table数组的初始化可以看出，串口read_q和write_q的data都是数据口的地址，而secondary的data是secondary中数据的行数。
尤其注意proc_list。对于读进程，当secondary没有数据时，将当前进程设置为可中断休眠，当数据到达时（由copy_to_cooked唤醒）会将进程设置为可运行状态。对于写进程，当write_q满时，将当前进程设置为可中断休眠，当write_q全部写完时（由串口中write_char子例程唤醒）会将进程设置为可运行状态。
con_write位于kernel/chr_dev/console.c（p201，第445行）中，这个函数可以说是显卡的驱动程序：
void con_write(struct tty_struct * tty)
{
int nr;
char c;
nr = CHARS(tty->write_q);
while (nr--)
{
GETCH(tty->write_q,c);
switch(state)
{
case 0:
if (c>31 &&c<127)
{
if(x>=video_num_columns)
{
x-= video_num_columns;
pos-= video_size_row;
lf();
}
__asm__("movb attr,%%ah\n\t"
"movw %%ax,%1\n\t"
::"a"(c),"m" (*(short *)pos)
);
pos+= 2;
x++;
}
else if (c==27)
state=1;
else if (c==10 || c==11 ||c==12)
lf();
else if (c==13)
cr();
else if(c==ERASE_CHAR(tty))
del();
else if (c==8)
{
if (x)
{
x--;
pos -= 2;
}
}
else if (c==9)
{
c=8-(x&7);
x += c;
pos += c<<1;
if (x>video_num_columns)
{
x -= video_num_columns;
pos -= video_size_row;
lf();
}
c=9;
}
else if (c==7)
sysbeep();
break;
case 1:
state=0;
if (c==‘[‘)
state=2;
else if (c==‘E‘)
gotoxy(0,y+1);
else if (c==‘M‘)
ri();
else if (c==‘D‘)
lf();
else if (c==‘Z‘)
respond(tty);
else if (x==‘7‘)
save_cur();
else if (x==‘8‘)
restore_cur();
break;
case 2:
for(npar=0; npar<NPAR; npar++)
par[npar]=0;
npar=0;
state=3;
if ((ques=(c==‘?‘)))
break;
case 3:
if (c==‘;‘ &&npar<NPAR-1)
{
npar++;
break;
}
else if (c>=‘0‘ &&c<=‘9‘)
{
par[npar]=10*par[npar]+c-‘0‘;
break;
}
else state=4;
case 4:
state=0;
switch(c)
{
case ‘G‘:
case ‘`‘:
if (par[0]) par[0]--;
gotoxy(par[0],y);
break;
case ‘A‘:
if (!par[0]) par[0]++;
gotoxy(x,y-par[0]);
break;
case ‘B‘:
case ‘e‘:
if (!par[0]) par[0]++;
gotoxy(x,y+par[0]);
break;
case ‘C‘:
case ‘a‘:
if (!par[0]) par[0]++;
gotoxy(x+par[0],y);
break;
case ‘D‘:
if (!par[0]) par[0]++;
gotoxy(x-par[0],y);
break;
case ‘E‘:
if (!par[0]) par[0]++;
gotoxy(0,y+par[0]);
break;
case ‘F‘:
if (!par[0]) par[0]++;
gotoxy(0,y-par[0]);
break;
case ‘d‘:
if (par[0]) par[0]--;
gotoxy(x,par[0]);
break;
case ‘H‘:
case ‘f‘:
if (par[0]) par[0]--;
if (par[1]) par[1]--;
gotoxy(par[1],par[0]);
break;
case ‘J‘:
csi_J(par[0]);
break;
case ‘K‘:
csi_K(par[0]);
break;
case ‘L‘:
csi_L(par[0]);
break;
case ‘M‘:
csi_M(par[0]);
break;
case ‘P‘:
csi_P(par[0]);
break;
case ‘@‘:
csi_at(par[0]);
break;
case ‘m‘:
csi_m();
break;
case ‘r‘:
if (par[0]) par[0]--;
if (!par[1]) par[1] =video_num_lines;
if (par[0] < par[1]&&
par[1] <=video_num_lines)
{
top=par[0];
bottom=par[1];
}
break;
case ‘s‘:
save_cur();
break;
case ‘u‘:
restore_cur();
break;
}
}
}
set_cursor();
}
con_write这个函数从write_q中获取一个字符，如果ASCII位于32–126之间，也就是可以显示的字符，直接显示字符即可（可能要换行，因为屏幕一般是25行，80列，同时还要注意设置字符的属性，也就是前景和背景的颜色等）。对于ASCII码0– 31, 127其实是控制字符，必须进行特殊处理。如\n= 10表示换行调到下一行的相同位置,\r = 13表示回车回到当前行的开头，BEL= 7表示扬声器发声，8表示退格符删除左边一个字符，\t= 9向下个8的整数倍的位置移动光标。控制序列（CSI）以ESC（ASCII=27）开头，如ESC[7m]是将字符显示为白底黑字（反显）。代码中的case1-case4都是在处理以ESC开头的控制序列。例子：write(fd,“hello\tworld!\n”, 20)。
上面的gotoxy在（kernel/chr_drv/console.c，p193,第88行)中：
/* NOTE! gotoxy thinksx==video_num_columns is ok */
static inline void gotoxy(unsigned int new_x,unsigned int new_y)
{
if (new_x >video_num_columns || new_y >= video_num_lines)
return;
x=new_x;
y=new_y;
pos=origin + y*video_size_row+ (x<<1);
}
其中video_num_columns= 80, video_num_lines = 25，表示一个屏幕的大小25行x80列，而且是以字符为单位的。这里的字符要占用两个字节，低字节用于设置字符的ASCII，高字节用于设置字符属性，最多可以显示2000个字符。而video_size_row表示一行占用的字节数，video_size_row= 160。
这里的origin是显示屏显示区域的起始地址，而且是个虚拟地址。而x,y是坐标，0<=x<=80,0<=y<25。pos是当前光标的虚拟地址，不过它是针对0xB8000而言的。对于一个屏幕，有两个地址需要设置。一个是显示屏起始地址origin，但寄存器是个16位的（分为两个8位寄存器，下同），所以填的是origin – 0xB8000。另一个地址是当前光标的位置pos，寄存器也是16位的，所以填的是pos – 0xB8000。
注意：显示屏的坐标与通常的坐标不一样，这里的坐标原点在左上角，与Java Swing中的界面的坐标语义类似。如下图：
上述的原点是其实就是origin。我们可以通过改变origin，也就是改变起始地址来改变显示的内存区域，实现滚屏的效果。事实上，显存是非常大的，通常是0xB8000–0xBFFFF，而显示屏显示的只是显存的冰山一角，这里把显存单独作为一个tty设备了。其实可以把显存划分为几块，只有一个键盘输入，对应设置多个tty，这样也就有了多个互不干扰的控制终端。通过按键Ctrl+Alt + F1-F7，分别进入不同的tty设备，设置该设备对应的显示屏地址和光标当前位置，实现多用户登录的功能。把内容写到当前光标位置pos（已经是指针），若落在当前[origin,src_end)里面就可以在屏幕看到该字符。src_end= origin + 4000。
另外，set_origin位于第97行：
static inline void set_origin(void)
{
cli();
outb_p(12, video_port_reg);
outb_p(0xff&((origin-video_mem_start)>>9),video_port_val);
outb_p(13, video_port_reg);
outb_p(0xff&((origin-video_mem_start)>>1),video_port_val);
sti();
}
set_cursor位于第313行：
static inline void set_cursor(void)
{
cli();
outb_p(14, video_port_reg);
outb_p(0xff&((pos-video_mem_start)>>9),video_port_val);
outb_p(15, video_port_reg);
outb_p(0xff&((pos-video_mem_start)>>1),video_port_val);
sti();
}
上面video_mem_start= 0xB8000，video_port_reg= 0x3B4，video_port_val= 0x3B5。
0xB8000是显存的起始地址，0x3B4是显存的索引寄存器，由于显卡端口众多，要访问各个数据寄存器，首先应该向端口0x3B4写入索引，表示接下来的数据由该索引对应的寄存器来接收。可以填写0-17，也就是最多可以索引17个寄存器。选择相应的索引后，通过0x3B5向该索引对应的寄存器写入数据，是8位寄存器。
12和13分别用于索引显示屏起始地址的高8位和低8位。14和15分别用于索引显示屏光标地址的高8位和低8位。注意这里都是以字符为单位，需要除以2。
rs_write位于kernel/chr_drv/serial.c(p211,第53行）中：
/*
* This routine gets calledwhen tty_write has put something into
* the write_queue. It mustcheck wheter the queue is empty, and
* set the interrupt registeraccordingly
*
* void _rs_write(structtty_struct * tty);
*/
void rs_write(struct tty_struct * tty)
{
cli();
if (!EMPTY(tty->write_q))
outb(inb_p(tty->write_q.data+1)|0x02,tty->write_q.data+1);
sti();
}
这个函数主要是在write_q有数据的情况下，将四个中断允许位中的写中断允许位（位1）置位。这个中断允许寄存器是0x3F9（主串口）或者0x2F9（辅串口）。这样的话，以后串口准备好时，就会自动把数据写到数据口中（0x3F8或者0x2F8）。
通过前面的讨论，我们已经知道了将数据写到显存中，就可以在显示屏显示数据，但依旧不知道这些数据是怎么获取到的，或者说键盘的输入是怎么处理的，如何读取串口中的数据。聪明的读者不难发现，tty_read读取的数据其实是保存在secondary辅助队列中的，那么secondary这个队列中的数据是怎么来的呢？是通过中断例程自动获取的。每次有数据到达，就会产生中断，如键盘中断IRQ1（33号中断）。串口1（主串口）的中断IRQ4是36号中断，串口2（辅串口）的中断IRQ3是35号中断。
键盘的中断入口在con_init(kernel/chr_drv/console.c，p207，第683行)这个函数中设置：
set_trap_gate(0x21,&keyboard_interrupt); outb_p(inb_p(0x21)&0xfd,0x21);
这里设置的是一个陷阱门，键盘中断时其他中断会被自动关闭。也就是在执行键盘中断例程时不允许其他中断的执行。
串口中断的入口绑定在rs_init(kernel/chr_drv/serial.c，p211，第37行）这个函数中设置：
void rs_init(void)
{
set_intr_gate(0x24,rs1_interrupt);
set_intr_gate(0x23,rs2_interrupt);
init(tty_table[1].read_q.data);
init(tty_table[2].read_q.data);
outb(inb_p(0x21)&0xE7,0x21);
}
这两个函数最后都向8259A发送中断允许控制字。
先来看看keyboard_interrupt（kernel/chr_drv/keyboard.S，p178）这个汇编函数：
/*
* con_int is the realinterrupt routine that reads the
* keyboard scan-code andconverts it into the appropriate
* ascii character(s).
*/
keyboard_interrupt:
pushl %eax
pushl %ebx
pushl %ecx
pushl %edx
push %ds
push %es
movl $0x10,%eax
mov %ax,%ds
mov %ax,%es
xor %al,%al /* %eax is scancode */
inb $0x60,%al
cmpb $0xe0,%al
je set_e0
cmpb $0xe1,%al
je set_e1
call key_table(,%eax,4)
movb $0,e0
e0_e1: inb $0x61,%al
jmp 1f
1: jmp 1f
1: orb $0x80,%al
jmp 1f
1: jmp 1f
1: outb %al,$0x61
jmp 1f
1: jmp 1f
1: andb $0x7F,%al
outb %al,$0x61
movb $0x20,%al
outb %al,$0x20
pushl $0
call do_tty_interrupt
addl $4,%esp
pop %es
pop %ds
popl %edx
popl %ecx
popl %ebx
popl %eax
iret
set_e0: movb $1,e0
jmp e0_e1
set_e1: movb $2,e0
jmp e0_e1
键盘某个键按下时会产生make扫描码，松开时会产生break扫描码。对于同一个按键，这两个码是有关系的，就是make码的最高位置1则是break码，这样刚好有256个扫描码。大部分按键产生的扫描码只有一个字节，但少数几个按键有两个字节，如RCtrl键make扫描码有两个字节，第一个是0xE0，而Pause键make有6个字节，且第一个是0xE1。通常我们只在乎make码，也就是按下的码。
从上面的函数可以看出，键盘的数据口是0x60。先从数据口读取数据，然后调用以扫描码为下标的key_table数组中的函数。调用完成后则会操作0x61端口先禁止键盘，再允许键盘，以对收到扫描码做出应答。最后会调用do_tty_interrupt(0)，对数据进行处理，并填到secondary队列中。
其中key_table位于同一个文件的第502行，调用的函数大都是do_self。我们也可以看到索引128以上大部分是调用none，也就是忽略。其他处理函数则是对mode的比特位进行相应设置，如左shift键按下，则mode的最低位置一，松开则置零。
我们可以看一下do_self（第453行），传递的寄存器参数是EAX扫描码：
/*
* do_self handles "normal"keys, ie keys that don‘t change meaning
* and which have just onecharacter returns.
*/
do_self:
lea alt_map,%ebx
testb $0x20,mode /* alt-gr*/
jne 1f
lea shift_map,%ebx
testb $0x03,mode
jne 1f
lea key_map,%ebx
1: movb (%ebx,%eax),%al
orb %al,%al
je none
testb$0x4c,mode /* ctrl or caps */
je 2f
cmpb$‘a,%al
jb 2f
cmpb$‘},%al
ja 2f
subb$32,%al
2: testb$0x0c,mode /* ctrl */
je 3f
cmpb$64,%al
jb 3f
cmpb$64+32,%al
jae 3f
subb$64,%al
3: testb$0x10,mode /* left alt */
je 4f
orb$0x80,%al
4: andl $0xff,%eax
xorl %ebx,%ebx
call put_queue
none: ret
do_self主要是通过看mode这个字节的比特位，看是否有Alt或者Shift键按下（按下不放），进而选择对应的映射表（alt_map或shift_map），否则就选择普通的key_map数组。这三个数组已经在内核代码中，且已经初始化，表示的是该键产生的扫描码对应的ASCII码，但是有的键是没有ASCII码的，用零表示，直接返回。
上面所有标出颜色的部分都等价于一个if语句，共有3个连续的if语句，满足条件则执行。第一个加粗部分获得对应的ASCII码，并存放在AL中。如果该ASCII码位于[97,125]且Caps键或Ctrl键按下，则减去32转化为大写字母。这里假设前面用的是key_map这个数组，而且都是小写字母的ASCII值，才能减去32。
接着，如果Ctrl键按下且ASCII码位于[64,96)（这个区间的大部分字符是大写字符，与上面是Ctrl键置位时是对应的，也就是Ctrl按下不放时，减去96，Ctrl+ a→1,Ctrl + b→2,…,Ctrl + z → 26），则再减去64，即转化为[0,31]（控制字符范围）的ASCII码，还是存放在AL中。如果左边的Alt按下，则AL的最高位置1。
将EAX= AL（高位补零，ASCII码）和EBX= 0这两个参数传递给put_queue这个函数处理。
put_queue这个函数在第88行：
/*
* This routine fills thebuffer with max 8 bytes, taken from
* %ebx:%eax. (%edx is high).The bytes are written in the
* order%al,%ah,%eal,%eah,%bl,%bh ... until %eax is zero.
*/
put_queue:
pushl %ecx
pushl %edx
movl table_list,%edx #read-queue for console
movl head(%edx),%ecx
1: movb %al,buf(%edx,%ecx)
incl %ecx
andl $size-1,%ecx
cmpl tail(%edx),%ecx #buffer full - discard everything
je 3f
shrdl $8,%ebx,%eax# EBX = 0，直接跳到2处执行
je 2f
shrl $8,%ebx
jmp 1b
2: movl %ecx,head(%edx)
movl proc_list(%edx),%ecx
testl %ecx,%ecx
je 3f
movl $0,(%ecx)
3: popl %edx
popl %ecx
ret
上面用到了table_list这个数组，它位于kernel/chr_drv/tty_io.c（p218）第99行：
/*
* these are the tables usedby the machine code handlers.
* you can implementpseudo-tty‘s or something by changing
* them. Currently not done.
*/
struct tty_queue *table_list[]=
{
&tty_table[0].read_q,&tty_table[0].write_q,
&tty_table[1].read_q,&tty_table[1].write_q,
&tty_table[2].read_q,&tty_table[2].write_q
};
上面加粗的部分使得EDX获得控制台终端读队列（tty_table[0].read_q）的地址，进而将一个字符AL写入到队头中，并将队头往前移位。需要注意的是队头一开始指向的位置为空，可以填充数据。而且这里使用的是循环队列，tail== head表示空，head+ 1 == tail表示队列已经满了。这里是在head这个位置先填数据了，再判断是否满了。
队列中缓冲区的数据存储如下：
key_table对应的函数处理完之后，键盘中断例程还要执行do_tty_interrupt(0)。这个函数位于kernel/chr_drv/tty_io.c（p224, 342行）：
/*
* Jeh, sometimes I reallylike the 386.
* This routine is called froman interrupt,
* and there should beabsolutely no problem
* with sleeping even in aninterrupt (I hope).
* Of course, if somebodyproves me wrong, I‘ll
* hate intel for all time:-). We‘ll have to
* be careful and see toreinstating the interrupt
* chips before calling this,though.
*
* I don‘t think we sleep hereunder normal circumstances
* anyway, which is good, asthe task sleeping might be
* totally innocent.
*/
void do_tty_interrupt(int tty)
{
copy_to_cooked(tty_table+tty);
}
而copy_to_cooked也在这个文件的第145行：
void copy_to_cooked(struct tty_struct * tty)
{
signed char c;
while (!EMPTY(tty->read_q)&& !FULL(tty->secondary))
{
GETCH(tty->read_q,c);
if (c==13)
if (I_CRNL(tty))
c=10;
else if (I_NOCR(tty))
continue;
else ;
else if (c==10 &&I_NLCR(tty))
c=13;
if (I_UCLC(tty))
c=tolower(c);
if (L_CANON(tty))
{
if (c==KILL_CHAR(tty))
{
/* deal with killing theinput line */
while(!(EMPTY(tty->secondary)||
(c=LAST(tty->secondary))==10 ||
c==EOF_CHAR(tty)))
{
if (L_ECHO(tty))
{
if (c<32)
PUTCH(127,tty->write_q);
PUTCH(127,tty->write_q);
tty->write(tty);
}
DEC(tty->secondary.head);
}
continue;
}
if (c==ERASE_CHAR(tty))
{
if (EMPTY(tty->secondary)||
(c=LAST(tty->secondary))==10 ||
c==EOF_CHAR(tty))
continue;
if (L_ECHO(tty))
{
if (c<32)
PUTCH(127,tty->write_q);
PUTCH(127,tty->write_q);
tty->write(tty);
}
DEC(tty->secondary.head);
continue;
}
if (c==STOP_CHAR(tty))
{
tty->stopped=1;
continue;
}
if (c==START_CHAR(tty))
{
tty->stopped=0;
continue;
}
}
if (L_ISIG(tty))
{
if (c==INTR_CHAR(tty))
{
tty_intr(tty,INTMASK);
continue;
}
if (c==QUIT_CHAR(tty))
{
tty_intr(tty,QUITMASK);
continue;
}
}
if (c==10 ||c==EOF_CHAR(tty))
tty->secondary.data++;
if (L_ECHO(tty))
{
if (c==10)
{
PUTCH(10,tty->write_q);
PUTCH(13,tty->write_q);
}
else if (c<32)
{
if (L_ECHOCTL(tty))
{
PUTCH(‘^‘,tty->write_q);
PUTCH(c+64,tty->write_q);
}
}
else
PUTCH(c,tty->write_q);
tty->write(tty);
}
PUTCH(c,tty->secondary);
}
wake_up(&tty->secondary.proc_list);
}
这个函数是实现行规则的关键，主要是对read_q进行遍历，如果是普通字符，则直接复制到tty->secondary中就可以了。如果设置了ICANON标志且当前字符是特殊字符，则对secondary进行处理。如果允许处理信号，则根据控制字符给相关的前台进程组发送对应的信号。同时根据标志，还能回显和控制回显等。
首先来了解EOF_CHAR(tty)的具体含义。在include/linux/tty.h（p410）中定义了：
#define INC(a) ((a) = ((a)+1)& (TTY_BUF_SIZE-1))
#define DEC(a) ((a) = ((a)-1)& (TTY_BUF_SIZE-1))
#define EMPTY(a) ((a).head ==(a).tail)
#define LEFT(a)(((a).tail-(a).head-1)&(TTY_BUF_SIZE-1))
#define LAST(a)((a).buf[(TTY_BUF_SIZE-1)&((a).head-1)])
#define FULL(a) (!LEFT(a))
#define CHARS(a)(((a).head-(a).tail)&(TTY_BUF_SIZE-1))
#define GETCH(queue,c) (void)({c=(queue).buf[(queue).tail];INC((queue).tail);})
#define PUTCH(c,queue) (void)({(queue).buf[(queue).head]=(c);INC((queue).head);})
#define INTR_CHAR(tty)((tty)->termios.c_cc[VINTR])
#define QUIT_CHAR(tty)((tty)->termios.c_cc[VQUIT])
#define ERASE_CHAR(tty)((tty)->termios.c_cc[VERASE])
#define KILL_CHAR(tty)((tty)->termios.c_cc[VKILL])
#define EOF_CHAR(tty) ((tty)->termios.c_cc[VEOF])
#define START_CHAR(tty)((tty)->termios.c_cc[VSTART])
#define STOP_CHAR(tty)((tty)->termios.c_cc[VSTOP])
#define SUSPEND_CHAR(tty)((tty)->termios.c_cc[VSUSP])
/* intr=^C quit=^\ erase=del kill=^U
eof=^D vtime=\0 vmin=\1 sxtc=\0
start=^Q stp=^S susp=^Z eol=\0
reprint=^R discard=^U werase=^W lnext=^V
eol2=\0
*/
#define INIT_C_CC"\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
在上面定义的tty_table中，使用INIT_C_CC这个数组初始化tty的termios结构的控制字符数组。上面VEOF即对应这个默认数组的下标。对于EOF这个字符每个tty都可以自己为其定义ASCII码，也就是对应的是哪个键。我们可以通过修改控制字符数组（termios）来更新对应的按键。
在include/termios.h（p374）中，定义了17个宏：
/* c_cc characters */ #define VINTR 0 #define VQUIT 1 #define VERASE 2 #define VKILL 3 #define VEOF 4 #define VTIME 5 #define VMIN 6 #define VSWTC 7 #define VSTART 8 #define VSTOP 9 #define VSUSP 10 #define VEOL 11 #define VREPRINT 12 #define VDISCARD 13 #define VWERASE 14 #define VLNEXT 15 #define VEOL2 16
所以每个控制字符都有一个ASCII码，如Ctrl+ D 的ASCII= 4，输入结束。Ctrl+ C对应的是3，加64则是C。所以如果设置了回显的话会有^C出现。
在tty设置规范模式（ICANON）的时候，copy_to_cooked会处理四个特殊字符。删除一行是Ctrl+U，从当前secondary队列的head开始往后删除，直到碰到换行或者文件结束符或者secondary队列空为止。删除一个字符是Ctrl+ H，往后移动secondary的head指针。如果tty有设置回显标志，则用一个DEL(ASCII=127)表示删除一个字符，如果该字符的ASCII<32则再显示一个DEL，输出到write_q中。由于该队列对应的是显示屏，所以显示屏还会对其做进一步的处理，如将光标处的字符变为空白，这样就看不到了。如果是\n，则会将光标往前移动一行。同时还对Ctrl+ S和Ctrl+ S进行处理。
注意：在secondary可以有\n字符，但是在屏幕上则必须实现其功能，即光标移动。对于删除操作，对于secondary，直接移动head即可，但对于write_q来说，必须发送127(DEL)或者8(backspace)，这样才会在con_write中移动光标。如在secondary可以有\t(ASCII=9)，但在屏幕上必须表现为至多8个空格。这些都是在con_write操作显示屏时进行实现的，copy_to_cooked只是对某些控制字符进行了操作，对\t不做处理。
如果tty设置了ISIG标志，则允许通过按键发送信号。按下Ctrl+ C，向整个前台进程组发送INT信号。按下Ctrl+ \，发送退出信号（产生进程映像的core文件）。
其中tty_intr(tty,INTMASK)，函数位于第111行：
void tty_intr(structtty_struct * tty, int mask)
{
int i;
if (tty->pgrp <= 0)
return;
for (i=0; i<NR_TASKS; i++)
if (task[i] &&task[i]->pgrp==tty->pgrp)
task[i]->signal |= mask;
}
如果有tty设置回显标志，则在写入secondary队列的同时，将数据写入到write_q中，并立即调用tty->write(tty)实时在显示屏显示，或者通过串口输出。如果当前ASCII码是个换行符(\n,ASCII = 10)，或者是文件结束符(Ctrl+ D)，则行数加一（tty->secondary.data++）。这些特殊字符会被写入到secondary中，包括Ctrl+ D。
串口的驱动程序是rs1_interrupt,rs2_interrupt。这两个函数位于kernel/chr_drv/rs_io.s(p213)中：
/*
* linux/kernel/rs_io.s
*
* (C) 1991 Linus Torvalds
*/
/*
* rs_io.s
*
* This module implements thers232 io interrupts.
*/
.code32
.text
.globlrs1_interrupt,rs2_interrupt
size = 1024 /* must bepower of two !
and must match thevalue
in tty_io.c!!! */
/* these are the offsets intothe read/write buffer structures */
rs_addr = 0
head = 4
tail = 8
proc_list = 12
buf = 16
startup = 256 /* chars leftin write queue when we restart it */
/*
* These are the actualinterrupt routines. They look where
* the interrupt is comingfrom, and take appropriate action.
*/
.align 2
rs1_interrupt:
pushl $table_list+8
jmp rs_int
.align 2
rs2_interrupt:
pushl $table_list+16
rs_int:
pushl %edx
pushl %ecx
pushl %ebx
pushl %eax
push %es
push %ds /* as this is aninterrupt, we cannot */
pushl $0x10 /* know that bsis ok. Load it */
pop %ds
pushl $0x10
pop %es
movl 24(%esp),%edx
movl (%edx),%edx
movl rs_addr(%edx),%edx
addl $2,%edx /* interruptident. reg */
rep_int:
xorl %eax,%eax
inb %dx,%al
testb $1,%al
jne end
cmpb $6,%al /* thisshouldn‘t happen, but ... */
ja end
movl 24(%esp),%ecx
pushl %edx
subl $2,%edx
call jmp_table(,%eax,2) /* NOTE! not *4, bit0 is 0 already */
popl %edx
jmp rep_int
end: movb $0x20,%al
outb %al,$0x20 /* EOI */
pop %ds
pop %es
popl %eax
popl %ebx
popl %ecx
popl %edx
addl $4,%esp # jump over_table_list entry
iret
jmp_table:
.longmodem_status,write_char,read_char,line_status
.align 2
modem_status:
addl $6,%edx /* clear intrby reading modem status reg */
inb %dx,%al
ret
.align 2
line_status:
addl $5,%edx /* clear intrby reading line status reg. */
inb %dx,%al
ret
.align 2
read_char:
inb %dx,%al
movl %ecx,%edx
subl $table_list,%edx
shrl $3,%edx
movl (%ecx),%ecx #read-queue
movl head(%ecx),%ebx
movb %al,buf(%ecx,%ebx)
incl %ebx
andl $size-1,%ebx
cmpl tail(%ecx),%ebx
je 1f
movl %ebx,head(%ecx)
1: pushl %edx
call do_tty_interrupt
addl $4,%esp
ret
.align 2
write_char:
movl 4(%ecx),%ecx #write-queue
movl head(%ecx),%ebx
subl tail(%ecx),%ebx
andl $size-1,%ebx # nr charsin queue
je write_buffer_empty
cmpl $startup,%ebx
ja 1f
movl proc_list(%ecx),%ebx #wake up sleeping process
testl %ebx,%ebx # is thereany?
je 1f
movl $0,(%ebx)
1: movl tail(%ecx),%ebx
movb buf(%ecx,%ebx),%al
outb %al,%dx
incl %ebx
andl $size-1,%ebx
movl %ebx,tail(%ecx)
cmpl head(%ecx),%ebx
je write_buffer_empty
ret
.align 2
write_buffer_empty:
movl proc_list(%ecx),%ebx #wake up sleeping process
testl %ebx,%ebx # is thereany?
je 1f
movl $0,(%ebx)
1: incl %edx
inb %dx,%al
jmp 1f
1: jmp 1f
1: andb $0xd,%al /* disabletransmit interrupt */
outb %al,%dx
ret
两个中断主要是数据保存的read_q不同，主串口在tty_table[1]，而辅串口在tty_table[2]。
上面函数加粗部分表示获得read_q的地址，并通过read_q.data获得数据端口。对于主串口，数据端口是0x3F8，而辅串口则是0x2F8。之后将通过加2获得中断发生寄存器端口0x3FA。如果该寄存器的最后一位（0位）置空，表示有中断。有中断时第1,2位构成四个可能的值，对应四种可能的中断，作为索引（EAX已经乘以2了）分别执行jmp_table所在处的函数。
使用寄存器传递参数。传递的参数主要是ECX=存放read_q指针的地址，EDX=0x3F8数据口。对于read_char类型的中断，直接通过数据口读取一个字节的数据并放到read_q，而且head++，最后调用do_tty_interrupt(1或2)，也就是copy_to_interrupt(1或2)。
键盘并没有写操作，所以控制台把键盘和显示屏绑在了一起，作为一个可以读写的tty设备。对于write_char，ECX+4为write_q的地址，对该队列进行操作即可，数据依旧是发送到0x3F8。注意一次中断只发送一个字符，如果write_q还有字符则不屏蔽写中断允许，可以继续进行写。否则将0x3F9(设置4个中断允许的寄存器)的第1位置位，表示不允许发生写中断。这个位可以在rs_write中被恢复设置。另外两种中断是状态变化的中断。
标签：dea nts put node 命令 操作 移位 文件操作 keyboard
原文地址：http://blog.csdn.net/ac_dao_di/article/details/53574288
