1.系统调用

什么是系统调用：

由操作系统实现并提供给外部应用程序的编程接口。(Application Programming Interface，API)。是应用程序同系统之间数据交互的桥梁。

C标准函数和系统函数调用关系。一个helloworld如何打印到屏幕。

2.C标准库文件IO函数

fopen、fclose、fseek、fgets、fputs、fread、fwrite......
  r 只读、 r+读写
w只写并截断为0、 w+读写并截断为0
a追加只写、 a+追加读写

3.open/close函数

3.1 函数原型

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

3.2 常用参数

O_RDONLY、O_WRONLY、O_RDWR    
O_APPEND、O_CREAT、O_EXCL、 O_TRUNC、 O_NONBLOCK
创建文件时，指定文件访问权限。权限同时受umask影响。结论为：
文件权限 = mode & ~umask
都变成二进制，掩码取反，然后与运算.
使用头文件：<fcntl.h>

3.3 open常见错误

1. 打开文件不存在 
2. 以写方式打开只读文件(打开文件没有对应权限)
3. 以只写方式打开目录

4.文件描述符

4.1 PCB进程控制块

PCB进程控制块：本质就是结构体，其中一个成员就是文件描述符表。文件描述符表中的每一个成员都是文件描述符。该表中能用的就是最小的。

0-STDIN_FILENO

1-STDOUT_FILENO

2-STDERR_FILENO

可使用命令locate sched.h查看位置：  
/usr/src/linux-headers-3.16.0-30/include/linux/sched.h  
struct task_struct
{
volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
/*
表示进程的当前状态:
TASK_RUNNING:正在运行或在就绪队列run-queue中准备运行的进程，实际参与进程调度。
TASK_INTERRUPTIBLE:处于等待队列中的进程，待资源有效时唤醒，也可由其它进程通过信号(signal)或定时中断唤醒后进入就绪队列run-queue。
TASK_UNINTERRUPTIBLE:处于等待队列中的进程，待资源有效时唤醒，不可由其它进程通过信号(signal)或定时中断唤醒。
TASK_ZOMBIE:表示进程结束但尚未消亡的一种状态(僵死状态)。此时，进程已经结束运行且释放大部分资源，但尚未释放进程控制块。
TASK_STOPPED:进程被暂停，通过其它进程的信号才能唤醒。导致这种状态的原因有二，或者是对收到SIGSTOP、SIGSTP、SIGTTIN或SIGTTOU信号的反应，或者是受其它进程的ptrace系统调用的控制而暂时将CPU交给控制进程。
TASK_SWAPPING: 进程页面被交换出内存的进程。
*/
unsigned long flags;  //进程标志，与管理有关,在调用fork()时给出
int sigpending;    　//进程上是否有待处理的信号
mm_segment_t addr_limit;  　//进程地址空间,区分内核进程与普通进程在内存存放的位置不同
/*用户线程空间地址: 0..0xBFFFFFFF。
内核线程空间地址: 0..0xFFFFFFFF */
struct exec_domain *exec_domain;  //进程执行域
volatile long need_resched;    　//调度标志,表示该进程是否需要重新调度,若非0,则当从内核态返回到用户态,会发生调度
unsigned long ptrace;
int lock_depth;  //锁深度
long counter;  　//进程的基本时间片,在轮转法调度时表示进程当前还可运行多久，在进程开始运行是被赋为priority的值，以后每隔一个tick(时钟中断)递减1，减到0时引起新一轮调 度。重新调度将从run_queue队列选出counter值最大的就绪进程并给予CPU使用权，因此counter起到了进程的动态优先级的作用
long nice;     //静态优先级
unsigned long policy;  //进程的调度策略,有三种,实时进程:SCHED_FIFO,SCHED_RR,分时进程:SCHED_OTHER
//在Linux 中, 采用按需分页的策略解决进程的内存需求。task_struct的数据成员mm 指向关于存储管理的mm_struct结构。
struct mm_struct *mm;  //进程内存管理信息
int has_cpu, processor;
unsigned long cpus_allowed;
struct list_head run_list;  //指向运行队列的指针
unsigned long sleep_time;  　//进程的睡眠时间
//用于将系统中所有的进程连成一个双向循环链表,其根是init_task
//在Linux 中所有进程(以PCB 的形式)组成一个双向链表,next_task和prev_task是链表的前后向指针
struct task_struct *next_task, *prev_task;
struct mm_struct *active_mm; //active_mm 指向活动地址空间。
struct linux_binfmt *binfmt;  //进程所运行的可执行文件的格式
int exit_code, exit_signal;
int pdeath_signal;    //父进程终止是向子进程发送的信号
unsigned long personality;
int dumpable:1;
int did_exec:1;
pid_t pid;  　//进程标识符,用来代表一个进程
pid_t pgrp;  //进程组标识,表示进程所属的进程组
pid_t tty_old_pgrp;  　//进程控制终端所在的组标识
pid_t session;      //进程的会话标识
pid_t tgid;
int leader;        //表示进程是否为会话主管
//指向最原始的进程任务指针，父进程任务指针，子进程任务指针，新兄弟进程任务指针，旧兄弟进程任务指针。
struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
struct list_head thread_group;   //线程链表
//用于将进程链入HASH表,系统进程除了链入双向链表外，还被加入到hash表中
struct task_struct *pidhash_next;
struct task_struct **pidhash_pprev;
wait_queue_head_t wait_chldexit;  　//供wait4()使用
struct semaphore *vfork_sem;     //供vfork()使用
unsigned long rt_priority;      //实时优先级，用它计算实时进程调度时的weight值
//it_real_value，it_real_incr用于REAL定时器，单位为jiffies,系统根据it_real_value
//设置定时器的第一个终止时间.在定时器到期时，向进程发送SIGALRM信号，同时根据
//it_real_incr重置终止时间，it_prof_value，it_prof_incr用于Profile定时器，单位为jiffies。
//当进程运行时，不管在何种状态下，每个tick都使it_prof_value值减一，当减到0时，向进程发送信号SIGPROF，并根据it_prof_incr重置时间.
//it_virt_value，it_virt_value用于Virtual定时器，单位为jiffies。当进程运行时，不管在何种
//状态下，每个tick都使it_virt_value值减一当减到0时，向进程发送信号SIGVTALRM，根据it_virt_incr重置初值
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_incr;
struct timer_list real_timer;  //指向实时定时器的指针
struct tms times;         //记录进程消耗的时间
unsigned long start_time;    //进程创建的时间
long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];//记录进程在每个CPU上所消耗的用户态时间和核心态时间
//内存缺页和交换信息:
//min_flt, maj_flt累计进程的次缺页数(Copyon　Write页和匿名页)和主缺页数(从映射文件或交换
//设备读入的页面数)；nswap记录进程累计换出的页面数，即写到交换设备上的页面数。
//cmin_flt, cmaj_flt,cnswap记录本进程为祖先的所有子孙进程的累计次缺页数，主缺页数和换出页面数。
//在父进程回收终止的子进程时，父进程会将子进程的这些信息累计到自己结构的这些域中
unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
int swappable:1;  　//表示进程的虚拟地址空间是否允许换出
//进程认证信息
//uid,gid为运行该进程的用户的用户标识符和组标识符，通常是进程创建者的uid，gid，euid，egid为有效uid,gid
//fsuid，fsgid为文件系统uid,gid，这两个ID号通常与有效uid,gid相等，在检查对于文件系统的访问权限时使用他们。
//suid，sgid为备份uid,gid
uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
int ngroups;    　//记录进程在多少个用户组中
gid_t groups[NGROUPS];  //记录进程所在的组
kernel_cap_t cap_effective, cap_inheritable, cap_permitted;//进程的权能，分别是有效位集合，继承位集合，允许位集合
int keep_capabilities:1;
struct user_struct *user;  //代表进程所属的用户
struct rlimit rlim[RLIM_NLIMITS];  　//与进程相关的资源限制信息
unsigned short used_math;  　//是否使用FPU
char comm[16];    　//进程正在运行的可执行文件名
//文件系统信息
int link_count;
struct tty_struct *tty;  //进程所在的控制终端，如果不需要控制终端，则该指针为空
unsigned int locks; /* How many file locks are being held */
//进程间通信信息
struct sem_undo *semundo;  //进程在信号量上的所有undo操作
struct sem_queue *semsleeping;  //当进程因为信号量操作而挂起时，他在该队列中记录等待的操作
struct thread_struct thread;  　//进程的CPU状态，切换时，要保存到停止进程的task_struct中
struct fs_struct *fs;    　//文件系统信息，fs保存了进程本身与VFS(虚拟文件系统)的关系信息
struct files_struct *files;　//打开文件信息,指向文件描述符号
//信号处理函数
spinlock_t sigmask_lock; /* Protects signal and blocked */
struct signal_struct *sig;　//信号处理函数
sigset_t blocked;      //进程当前要阻塞的信号，每个信号对应一位
struct sigpending pending; //进程上是否有待处理的信号
unsigned long sas_ss_sp;
size_t sas_ss_size;
int (*notifier)(void *priv);
void *notifier_data;
sigset_t *notifier_mask;
/* Thread group tracking */
u32 parent_exec_id;
u32 self_exec_id;
spinlock_t alloc_lock; //用于申请空间时用的自旋锁。自旋锁的主要功能是临界区保护
};

4.2 文件描述图表

结构体PCB 的成员变量file_struct *file 指向文件描述符表。

从应用程序使用角度，该指针可理解记忆成一个字符指针数组，下标0/1/2/3/4…找到文件结构体。

本质是一个键值对0、1、2…都分别对应具体地址。但键值对使用的特性是自动映射，我们只操作键不直接使用值。

新打开文件返回文件描述符表中未使用的最小文件描述符。

STDIN_FILENO    0
STDOUT_FILENO   1
STDERR_FILENO 2

4.3 最大打开文件数

一个进程默认打开文件的个数1024。      
命令查看ulimit -a 查看open files 对应值。默认为1024    
 可以使用ulimit -n 4096 修改    
 当然也可以通过修改系统配置文件永久修改该值，但是不建议这样操作。
 cat /proc/sys/fs/file-max可以查看该电脑最大可以打开的文件个数。
受内存大小影响。

4.4 FIFE结构体

主要包含文件描述符、文件读写位置、IO缓冲区三部分内容。 
struct file {
  ...
  文件的偏移量；
  文件的访问权限；
  文件的打开标志；
  文件内核缓冲区的首地址；
  struct operations * f_op;
  ...  
    };      
查看方法：
    (1) /usr/src/linux-headers-3.16.0-30/include/linux/fs.h  
    (2) lxr：百度 lxr → lxr.oss.org.cn → 选择内核版本(如3.10) → 点击File Search进行搜索 
  → 关键字：“include/linux/fs.h” → Ctrl+F 查找 “struct file {” 
→ 得到文件内核中结构体定义
  → “struct file_operations”文件内容操作函数指针 
  → “struct inode_operations”文件属性操作函数指针

5. read/write 函数

ssize_t read(int fd, void *buf, size_t count); 
ssize_t write(int fd, const void *buf, size_t count); 
read与write函数原型类似。使用时需注意：read/write函数的第三个参数。

练习：编写程序实现简单的cp功能。

程序比较：如果一个只读一个字节实现文件拷贝，使用read、write效率高，还是使用对应的标库函数(fgetc、fputc)效率高呢？

5.1 strace命令

shell中使用strace命令跟踪程序执行，查看调用的系统函数。

5.2 缓冲区

read、write函数常常被称为Unbuffered I/O。指的是无用户及缓冲区。但不保证不使用内核缓冲区。

5.3 预读入缓输出

6.错误处理函数

错误号：errno
perror函数：    void perror(const char *s); 
strerror函数： char *strerror(int errnum); 
查看错误号：  
/usr/include/asm-generic/errno-base.h
     /usr/include/asm-generic/errno.h
#define EPERM  1  /* Operation not permitted */
#define ENOENT  2  /* No such file or directory */
#define ESRCH  3  /* No such process */
#define EINTR  4  /* Interrupted system call */
#define EIO   5  /* I/O error */
#define ENXIO  6  /* No such device or address */
#define E2BIG  7  /* Argument list too long */
#define ENOEXEC  8  /* Exec format error */
#define EBADF  9  /* Bad file number */
#define ECHILD  10  /* No child processes */
#define EAGAIN  11  /* Try again */
#define ENOMEM  12  /* Out of memory */
#define EACCES  13  /* Permission denied */
#define EFAULT  14  /* Bad address */
#define ENOTBLK  15  /* Block device required */
#define EBUSY  16  /* Device or resource busy */
#define EEXIST  17  /* File exists */
#define EXDEV  18  /* Cross-device link */
#define ENODEV  19  /* No such device */
#define ENOTDIR  20  /* Not a directory */
#define EISDIR  21  /* Is a directory */
#define EINVAL  22  /* Invalid argument */
#define ENFILE  23  /* File table overflow */
#define EMFILE  24  /* Too many open files */
#define ENOTTY  25  /* Not a typewriter */
#define ETXTBSY  26  /* Text file busy */
#define EFBIG  27 /* File too large */
#define ENOSPC  28  /* No space left on device */
#define ESPIPE  29  /* Illegal seek */
#define EROFS  30  /* Read-only file system */
#define EMLINK  31  /* Too many links */
#define EPIPE  32  /* Broken pipe */
#define EDOM  33  /* Math argument out of domain of func */
#define ERANGE  34  /* Math result not representable */

7.阻塞、非阻塞

读常规文件是不会阻塞的，不管读多少字节，read一定会在有限的时间内返回。从终端设备或网络读则不一定，如果从终端输入的数据没有换行符，调用read读终端设备就会阻塞，如果网络上没有接收到数据包，调用read从网络读就会阻塞，至于会阻塞多长时间也是不确定的，如果一直没有数据到达就一直阻塞在那里。同样，写常规文件是不会阻塞的，而向终端设备或网络写则不一定。

现在明确一下阻塞（Block）这个概念。当进程调用一个阻塞的系统函数时，该进程被置于睡眠（Sleep）状态，这时内核调度其它进程运行，直到该进程等待的事件发生了（比如网络上接收到数据包，或者调用sleep指定的睡眠时间到了）它才有可能继续运行。与睡眠状态相对的是运行（Running）状态，在Linux内核中，处于运行状态的进程分为两种情况：

正在被调度执行。CPU处于该进程的上下文环境中，程序计数器（eip）里保存着该进程的指令地址，通用寄存器里保存着该进程运算过程的中间结果，正在执行该进程的指令，正在读写该进程的地址空间。

就绪状态。该进程不需要等待什么事件发生，随时都可以执行，但CPU暂时还在执行另一个进程，所以该进程在一个就绪队列中等待被内核调度。系统中可能同时有多个就绪的进程，那么该调度谁执行呢？内核的调度算法是基于优先级和时间片的，而且会根据每个进程的运行情况动态调整它的优先级和时间片，让每个进程都能比较公平地得到机会执行，同时要兼顾用户体验，不能让和用户交互的进程响应太慢。

阻塞读终端：    【block_readtty.c】
非阻塞读终端    【nonblock_readtty.c】
非阻塞读终端和等待超时  【nonblock_timeout.c】

注意，阻塞与非阻塞是对于文件而言的。而不是read、write等的属性。read终端，默认阻塞读。

总结read 函数返回值：

1. 返回非零值：  实际read到的字节数
2. 返回-1：  1）：errno != EAGAIN (或!= EWOULDBLOCK)  read出错
2）：errno == EAGAIN (或== EWOULDBLOCK)  设置了非阻塞读，并且没有数据到达。
3. 返回0：读到文件末尾

附上测试代码：

阻塞方式打开设备文件：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.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;
}

非阻塞方式打开设备文件：

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
        char buf[10];
        int fd,n;
        fd=open("/dev/tty",O_RDONLY|O_NONBLOCK);
        if(fd<0){
                perror("open /dev/tty");
                exit(1);
        }
tryagain:
        n = read(fd,buf,10);
        if(n<0){
                if(errno != EAGAIN ){ //if(errno!=EWOULDBLOCK)
                perror("read /dev/tty");
                exit(1);
                }else{
                write(STDOUT_FILENO,"try again\n",strlen("try again\n"));
                sleep(2);
                goto tryagain;
                }
        }
        write(STDOUT_FILENO,buf,n);
        close(fd);
        return 0;
}

非阻塞设置超时：

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MSG_TRY "try again\n"
#define MSG_TIMEOUT "time out\n"
int main(void)
{
        char buf[10];
        int fd,n,i;
        fd=open("/dev/tty",O_RDONLY|O_NONBLOCK);
        if(fd<0){
                perror("open /dev/tty");
                exit(1);
        }
        printf("open /dev/tty ok... %d\n",fd);
        for(i=0;i<5;i++){
                n = read(fd,buf,10);
                if(n<0){
                        if(errno != EAGAIN ){ //if(errno!=EWOULDBLOCK)
                        perror("read /dev/tty");
                        exit(1);
                        }else{
                        write(STDOUT_FILENO,MSG_TRY,strlen(MSG_TRY));
                        sleep(2);
                }
                }
        }
        if(i==5){
                write(STDOUT_FILENO,MSG_TIMEOUT,strlen(MSG_TIMEOUT));
        }else{
        write(STDOUT_FILENO,buf,n);
        }
        close(fd);
  return 0;
}

8.lseek函数

8.1 文件偏移

Linux中可使用系统函数lseek来修改文件偏移量(读写位置)

每个打开的文件都记录着当前读写位置，打开文件时读写位置是0，表示文件开头，通常读写多少个字节就会将读写位置往后移多少个字节。但是有一个例外，如果以O_APPEND方式打开，每次写操作都会在文件末尾追加数据，然后将读写位置移到新的文件末尾。lseek和标准I/O库的fseek函数类似，可以移动当前读写位置（或者叫偏移量）。

回忆fseek的作用及常用参数。 SEEK_SET、SEEK_CUR、SEEK_END
    int fseek(FILE *stream, long offset, int whence);  成功返回0；失败返回-1
      特别的：超出文件末尾位置返回0；往回超出文件头位置，返回-1
    off_t lseek(int fd, off_t offset, int whence); 失败返回-1；成功：返回的值是较文件起始位置向后的偏移量。
特别的：lseek允许超过文件结尾设置偏移量，文件会因此被拓展。
    注意文件“读”和“写”使用同一偏移位置。

【lseek.c】

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
int main(void){
        int fd,n;
        char msg[]="it's a test foe lseek\n";
        char ch;
        fd = open("lseek.txt",O_RDWR|O_CREAT,0644);
        if(fd<0)
        {
                perror("open lseek.txt error");
                exit(1);
        }
        write(fd,msg,strlen(msg));
        lseek(fd,0,SEEK_SET);
        while((n=read(fd,&ch,1))){
                if(n<0){
                        perror("read error");
                        exit(1);
                }
                write(STDOUT_FILENO,&ch,n);
        }
        close(fd);
        return 0;
}
~

8.2 lseek常用应用

1. 使用lseek拓展文件：write操作才能实质性的拓展文件。单lseek是不能进行拓展的。   
  一般：write(fd, "a", 1);        
od -tcx filename  查看文件的16进制表示形式
        od -tcd filename  查看文件的10进制表示形式
  使用truncate函数，直接拓展文件。
2. 通过lseek获取文件的大小：lseek(fd, 0, SEEK_END);  【lseek_test.c】
    【最后注意】：lseek函数返回的偏移量总是相对于文件头而言。

【lseek_test.c】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
        int fd = open(argv[1],O_RDWR);
        if(fd == -1)
        {
                perror("open error");
                exit(1);
        }
        int lenth = lseek(fd,0,SEEK_END);
        printf("file size:%d\n",lenth);
        return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int main(int argc,char *argv[])
{
        //open/lseek(fd,249,SEEK_END)/write(fd,"\0",1);
        int ret =truncate("lseek.txt",250);//in there ,it must own an knowned file.
        printf("ret = %d\n",ret);
        return 0;
}

9.fcntl函数

改变一个【已经打开】的文件的 访问控制属性。
    重点掌握两个参数的使用，
    F_GETFL 和 F_SETFL。
fcntl :
  int flgs =fcntl(fd,F_GETFL);
  获取文件状态：F_GETFL
  设置文件状态：F_SETFL

位图：

位图就是使用一个比特位来进行表示数据存在与否的信息。

这里面的flags就是位图

【fcntl.c】

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#define MSG_TRY "try again\n"
int main(void)
{
        char buf[10];
        int flags ,n;
        flags = fcntl(STDIN_FILENO,F_GETFL);
        if(flags == -1){
                perror("fcntl error");
                exir(1);
        }
        flags |= O_NONBLOCK;
        int ret = fcntl(STDIN_FILENO,F_SETFL,flags);
        if(ret == -1){
                perror("fcntl error");
                exit(1);
        }
tryagain:
        n=read(STDIN_FILENO,buf,10);
        if(n<0){
                if(errno != EAGAIN){
                        perror("read /dev/tty");
                        exit(1);
                }
        sleep(3);
        write(STDOUT_FILENO,MSG_TRY,strlen(MSG_TRY));
        goto tryagain;
        }       
        write(STDOUT_FILENO,buf,n);     
        return 0;
}

10.ioctl 函数

对设备的I/O通道进行管理，控制设备特性。(主要应用于设备驱动程序中)。
通常用来获取文件的【物理特性】（该特性，不同文件类型所含有的值各不相同）

11.传入输出参数

11.1传入参数

const 关键字修饰的 指针变量  在函数内部读操作。  char *strcpy(cnost char *src, char *dst);

11.2 传出参数

1. 指针做为函数参数 
2. 函数调用前，指针指向的空间可以无意义，调用后指针指向的空间有意义，且作为函数的返回值传出  
3. 在函数内部写操作。

11.3 传入传出参数

传入参数：
  1.指针作为函数参数
  2.通常const关键字修饰
  3.指针指向有效区域，在函数内部做读操作
传出参数：
  1.指针作为函数参数
  2.在函数调用之前，指针指向的空间可以无意义，但必须有效
  3.在函数内部，做写操作。
  4.函数调用结束后，充当函数返回值。
传入传出参数：
  1.指针作为函数参数
  2.在函数调用之前，指针有实际意义
  3.在函数内部，先做读操作，后做写操作
  4.函数调用结束后，充当函数返回值。

拓展阅读

关于虚拟4G内存的描述和解析：一个进程用到的虚拟地址是由内存区域表来管理的，实际用不了4G。而用到的内存区域，会通过页表映射到物理内存。

所以每个进程都可以使用同样的虚拟内存地址而不冲突，因为它们的物理地址实际上是不同的。内核用的是3G以上的1G虚拟内存地址，其中896M是直接映射到物理地址的，128M按需映射896M以上的所谓高位内存。各进程使用的是同一个内核。

首先要分清“可以寻址”和“实际使用”的区别。

其实我们讲的每个进程都有4G虚拟地址空间，讲的都是“可以寻址”4G，意思是虚拟地址的0-3G对于一个进程的用户态和内核态来说是可以访问的，而3-4G是只有进程的内核态可以访问的。并不是说这个进程会用满这些空间。

其次，所谓“独立拥有的虚拟地址”是指对于每一个进程，都可以访问自己的0-4G的虚拟地址。虚拟地址是“虚拟”的，需要转化为“真实”的物理地址。

好比你有你的地址簿，我有我的地址簿。你和我的地址簿都有1、2、3、4页，但是每页里面的实际内容是不一样的，我的地址簿第1页写着3你的地址簿第1页写着4，对于你、我自己来说都是用第1页（虚拟），实际上用的分别是第3、4页（物理），不冲突。

内核用的896M虚拟地址是直接映射的，意思是只要把虚拟地址减去一个偏移量（3G）就等于物理地址。同样，这里指的还是寻址，实际使用前还是要分配内存。而且896M只是个最大值。如果物理内存小，内核能使用（分配）的可用内存也小。

linux系统编程（五）针对linux系统中文件的IO操作