linux 系统编程学习笔记一

文件与i/o

汇编程序的hello world

.data #section

declaration

msg:

.ascii "hello world!\n" #our dear

string

len= . - msg #length of our

dear string

.text #section

declaration

#we must export the entry

point to the ELF linker or

.global _start #loader.they conventionally

recognize _start as their

#entry point. use ld -e foo to

override the default.

_start:

#write our string to stdout

movl $len,%edx #third argument:

message length

movl $msg,%etc #second argument:

pointer to message to write

movl $1,%ebx #first argument: file

handle(stdout)

movl $4,%eax #system call number

(sys_write)

int $0x80 #call kernel

#and exit

movl $0,%ebx #first argument:exit

code

movl $1,%eax #system call number

(sys_exit)

int $0x80 #call kernel

汇编：as -o hello.c hello.s

链接：ld -o hello hello.o

运行：./hello

以上代码等同于以下c代码：

#include <stdio.h>

char msg[14]="hello world!\n";

#define len 14

int main(void){

write(1,msg,len);

_exit(0);

}

c标准I/O与unbuffered I/O函数

c标准I/O用系统调用实现

fopen(3) 调用open打开文件,返回一个文件描述符，分配一个FILE结构体

fgetc(3) 通过传入的FILE参数，检查能否从I/O缓冲区读到下一个字符，如果

能就直接读，否则就调用read(2),把文件描述符传进去，让内核读取该文件

到I/O缓冲区

fputc(3) 同上，如果i/o缓冲区已满就调用write(2),把缓冲区内容写入文件

fclose(3) 如果缓冲区有未写入，则调用write(2)写回文件，然后调用close(2)关闭文

件，释放结构体和缓冲区

open\read\write\close等系统函数为无缓冲I/O(unbuffered I/O)

文件描述符：文件描述符表中的索引

每个进程linux内核都有一个task_struct结构体来维护进程相关信息，即进程描述符

（process descriptor） 或是进程控制块（pcb process control block）

task_struct中有一个指针指向files_struct结构体，称为文件描述符表

当调用open打开一个或创建一个新文件时，内核分配一个文件描述符返回给用户，

文件描述符表中的指针指向新打开文件

程序启动会打开三个文件：

标准输入stdtin 文件描述符为0

标准输出stdout 1

标准错误输出stderr 2

在头文件unistd.h中定义

#define STDIN_FILENO 0

#define STDOUT_FILENO 1

#define STDERR_FILENO 2

open/close

open打开或创建一个文件

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

/*返回新分配的文件描述符，出错返回-1*/

/*

pathname 文件名

flag常数值

必选项

O_RDONLY 只读

O_WRONLY 只写

O_RDWR 可读可写

可选项

O_APPEND 追加

O_CREAT 文件不存则创建

O_EXCL

O_TRUNC 如果文件已存在，且以只写或可读可写打开，则将其长度截断为0字节

*/

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

/*mode指定文件权限，可用八进制表示，0644表示-rw-r--r--

文件的权限由open的mode参数和当前进程的umask掩码决定

*/

int open(const char *pathname,int flags,mode_t mode);

close 关闭一个打开的文件

#include <stdio.h>

/*成功返回0

fd为文件描述符

*/

int close(int fd);

read/write

read 从打开的文件或设备中读取数据

#include <unistd.h>

/*成功返回字节数，出错返回顾-1，如果在调用前已到达文件末尾，返回0*/

/*count 表示请求读取的字节数

buf 数据保存缓冲区

ssize_t 表示有符号的size_t

*/

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

write 向打开的设备或文件中定数据

#include <unistd.h>

/*返回值通常等于count*/

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

示例代码：

从终端读数据再写回终端

#include <unistd.h>

#include <stdlib.h>

/*阻塞读终端*/

int main(void){

char buf[10];

int n;

n=read(STDIN_FILENO,buf,10);

if(n<0){

perror("read stdin_fileno");

exit(1);

}

write(STDOUT_FILENO,buf,n);

return 0;

}

运行结果：

yuezhenhua@ubuntu:/opt/sdk/tc$ gcc test40.c -o test40

yuezhenhua@ubuntu:/opt/sdk/tc$ ./test40

hello

hello

yuezhenhua@ubuntu:/opt/sdk/tc$ ./test40

hello world

hello worlyuezhenhua@ubuntu:/opt/sdk/tc$ d

d：找不到命令

执行过程：

shell进程创建test40进程，test40开始执行，shell进程睡眠等待test40退出

test40调用read时睡眠等待，直到终端设备输入换行符才从read返回，read只读取10个字符

剩余的字符仍然保存在内核的终端设备输入缓冲区中

test40进程打印并退出，这时shell进程恢复运行，从终端设备读取用户输入的命令

于是读走了终端设备输入缓冲区中剩余的字符d和换行符，把它当作一条命令解释执行

监视多个设备

while(1){

非阻塞read(设备一);

if(设备一有数据到达){

处理数据;

}

非阻塞read(设备二);

if(设备二有数据到达){

处理数据;

}

/*延迟一会儿再查询*/

sleep(n);

}

注：select(2)函数可以在阻塞的同时监视多个设备

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#define MSG_TRY "try again\n"

/*非阻塞读终端*/

int main(void){

char buf[10];

int fd,n;

fd=open("/dev/tty",O_RDONLY|O_NONBLOCK);

if(fd<0){

perror("open file /dev/tty");

exit(1);

}

tryagain:

n=read(fd,buf,10);

if(n<0){

if(errno==EAGAIN){

sleep(1);

write(STDOUT_FILENO,MSG_TRY,strlen(MSG_TRY));

goto tryagain;

}

perror("read /dev/tty");

exit(1);

}

write(STDOUT_FILENO,buf,n);

close(fd);

return 0;

}

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#define MSG_TRY "try again\n"

#define MSG_TIMEOUT "timeout\n"

/*非阻塞读终端和等待超时*/

int main(void){

char buf[10];

int fd,n,i;

fd=open("/dev/tty",O_RDONLY|O_NONBLOCK);

if(fd<0){

perror("open file /dev/tty");

exit(1);

}

for(i=0;i<5;i++){

n=read(fd,buf,10);

if(n>=0){

break;

}

if(errno!=EAGAIN){

perror("read /dev/tty");

exit(1);

}

sleep(1);

write(STDOUT_FILENO,MSG_TRY,strlen(MSG_TRY));

}

if(i==5){

write(STDOUT_FILENO,MSG_TIMEOUT,strlen(MSG_TIMEOUT));

}else{

write(STDOUT_FILENO,buf,10);

}

close(fd);

return 10;

}