内核对文件的管理

1,文件元数据。
stat结构体:

struct stat
{
mode_t st_mode; //文件对应的模式，文件，目录等
ino_t st_ino; //i-node节点号
dev_t st_dev; //设备号码
dev_t st_rdev; //特殊设备号码
nlink_t st_nlink; //文件的连接数
uid_t st_uid; //文件所有者
gid_t st_gid; //文件所有者对应的组
off_t st_size; //普通文件，对应的文件字节数
time_t st_atime; //文件最后被访问的时间
time_t st_mtime; //文件内容最后被修改的时间
time_t st_ctime; //文件状态（属性）改变时间
blksize_t st_blksize; //文件内容对应的块大小
blkcnt_t st_blocks; //文件内容对应的块数量
};

返回stat结构体:
struct stat finfo;
stat( const char* filename, &finfo );
fstat( int fd, &finfo );
实例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include <time.h>

int main()
{
    struct stat filestat;
    char* filename = "file.txt";
    char* type;
    char* readok;
    char timebuf[26];;
    if (stat(filename, &filestat) < 0)
        fprintf(stderr, "stat error: %s", strerror(errno));
    if (S_ISREG(filestat.st_mode))
        type = "regular";
    else if (S_ISREG(filestat.st_mode))
        type = "directory";
    else
        type = "other";
    fprintf(stdout,"type: %s\n", type);
    if ((filestat.st_mode & S_IRUSR))
        readok = "yes";
    else
        readok = "no";
    fprintf(stdout,"usr read: %s\n", readok);
    strcpy(timebuf, ctime(&filestat.st_mtime));
    fprintf(stdout, "Time modified : %s", timebuf);
    fprintf(stdout, "filesize : %d", (int)filestat.st_size);
    return 0;
}

2，关于文件共享：
内核用三种相关的数据结构表示打开的文件：
（1）描述符表：每个进程都有自己独立的描述符表。
表的每一项指向文件表中的一个表项。
（2）文件表：所有进程共享。
每一项包括三个内容：文件当前位置；引用计数；指向v-node表项的指针。
注：关闭一个文件描述符，引用计数减1。当引用计数为0时，内核才会删除这个表项。
（3）v-node表：所有进程共享。
每一项包括stat结构中的大多数信息。

3,多个描述符可以通过不同的文件表项指向同一个文件。
此时，文件对不同描述符的偏移位置不同。




4，子进程有一个父进程表的副本。
相当于父进程描述符指向的表项引用计数都要加1。



5，I/O重定向
dup(4,1); //结果：标准输出的描述符指向4所在的表项。
实例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <time.h>
#include <sys/wait.h>

void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}

int Open(const char *pathname, int flags, mode_t mode)
{
    int rc;
    if ((rc = open(pathname, flags, mode))  < 0)
        unix_error("Open error");
    return rc;
}

ssize_t Read(int fd, void *buf, size_t count)
{
    ssize_t rc;
    if ((rc = read(fd, buf, count)) < 0)
        unix_error("Read error");
    return rc;
}

pid_t Fork(void)
{
    pid_t pid;

    if ((pid = fork()) < 0)
        unix_error("Fork error");
    return pid;
}

pid_t Wait(int *status)
{
    pid_t pid;

    if ((pid  = wait(status)) < 0)
        unix_error("Wait error");
    return pid;
}

int Dup2(int fd1, int fd2)
{
    int rc;

    if ((rc = dup2(fd1, fd2)) < 0)
        unix_error("Dup2 error");
    return rc;
}

int main()
{
    int fd1, fd2;
    char c;
    fd1 = Open("file.txt", O_RDONLY, 0);
    fd2 = Open("file.txt", O_RDONLY, 0);
    Read(fd1, &c, 1);
    fprintf(stdout, "%c\n", c);
    Read(fd2, &c, 1);
    fprintf(stdout, "%c\n", c);
    //注：fd1和fd2通过不同的表项指向同一个文件，文件的偏移独立。
    if (Fork() == 0)
    {
        Read(fd1, &c, 1);//子进程和父 进程指向同一个表项，文件偏移一样。
        fprintf(stdout, "%c\n", c); //打印第二个字符
        exit(0);
    }
    Wait(NULL);
    Read(fd1, &c, 1);//子进程修改的偏移影响到了父进程
    fprintf(stdout, "%c\n", c); //打印第三个字符

    Dup2(fd2, fd1);
    Read(fd1, &c, 1); //fd2指向的文件表项发生了偏移
    fprintf(stdout, "%c\n", c); //打印第 2个字符

    return 0;
}