c /c++复习笔记 第四天

=================================

文件系统(下)

一、 sync和fsync以及fdatasync

---

基本介绍

1. 大多数磁盘I/O都通过缓冲进行，
   写入文件其实只是写入缓冲区，直到缓冲区满，
   才将其排入写队列。

2. 延迟写降低了写操作的次数，提高了写操作的效率，
   但可能导致磁盘文件与缓冲区数据不同步。

3. sync/fsync/fdatasync用于强制磁盘文件与缓冲区同步。

4. sync将所有被修改过的缓冲区排入写队列即返回，
   不等待写磁盘操作完成。

5. fsync只针对一个文件，且直到写磁盘操作完成才返回。

6. fdatasync只同步文件数据，不同步文件属性。

函数说明

#include 

void sync (void);

int fsync (
    int fd
);

成功返回0，失败返回-1。

int fdatasync (
    int fd
);

成功返回0，失败返回-1。

解析流程

              +-fwrite-> 标准库缓冲 -fflush-+             sync
应用程序内存 -+                             +-> 内核缓冲 -fdatasync-> 磁盘(缓冲)
              +------------write------------+             fsync

二、 fcntl

---

函数说明

#include 
int fcntl (
    int fd,  // 文件描述符
    int cmd, // 操作指令
    ...      // 可变参数，因操作指令而异
);

对fd文件执行cmd操作，某些操作需要提供参数。

1. 常用形式

~~~~~~~

#include 

int fcntl (int fd, int cmd);
int fcntl (int fd, int cmd, long arg);

成功返回值因cmd而异，失败返回-1。

cmd取值：

F_DUPFD - 复制fd为不小于arg的文件描述符。
若arg文件描述符已用，
该函数会选择比arg大的最小未用值，
而非如dup2函数那样关闭之。

范例：dup.c

#include 
#include 
#include 
#include 
int main (void) {
    int fd1 = open ("dup.txt", O_RDWR | O_CREAT |
        O_TRUNC, 0664);
    if (fd1 == -1) {
        perror ("open");
        return -1;
    }
    printf ("fd1 = %d\n", fd1);
    int fd2 = dup (fd1);
    if (fd2 == -1) {
        perror ("dup");
        return -1;
    }
    printf ("fd2 = %d\n", fd2);
    int fd3 = dup2 (fd2, 100);
    if (fd3 == -1) {
        perror ("dup2");
        return -1;
    }
    printf ("fd3 = %d\n", fd3);
    const char* text = "Hello, World !";
    if (write (fd1, text,
        strlen (text) * sizeof (text[0])) == -1) {
        perror ("write");
        return -1;
    }
    if (lseek (fd2, -7, SEEK_CUR) == -1) {
        perror ("lseek");
        return -1;
    }
    text = "Linux";
    if (write (fd3, text,
        strlen (text) * sizeof (text[0])) == -1) {
        perror ("write");
        return -1;
    }
    close (fd3);
    close (fd2);
    close (fd1);
    return 0;
}

F_GETFD - 获取文件描述符标志。

F_SETFD - 设置文件描述符标志。

目前仅定义了一个文件描述符标志位FD_CLOEXEC：

0 - 在通过execve()函数所创建的进程中，
该文件描述符依然保持打开。

1 - 在通过execve()函数所创建的进程中，
该文件描述符将被关闭。

F_GETFL - 获取文件状态标志。
不能获取O_CREAT/O_EXCL/O_TRUNC。

F_SETFL - 追加文件状态标志。
只能追加O_APPEND/O_NONBLOCK。

范例：flags.c

这里写代码片

2. 文件锁

~~~~~

函数说明

#include 

int fcntl (int fd, int cmd, struct flock* lock);

其中：

struct flock {
    short int l_type;   // 锁的类型：
                        // F_RDLCK/F_WRLCK/F_UNLCK
                        // (读锁/写锁/解锁)
    short int l_whence; // 偏移起点：
                        // SEEK_SET/SEEK_CUR/SEEK_END
                        // (文件头/当前位置/文件尾)
    off_t     l_start;  // 锁区偏移，从l_whence开始
    off_t     l_len;    // 锁区长度，0表示锁到文件尾
    pid_t     l_pid;    // 加锁进程，-1表示自动设置
};

参数说明

cmd取值：

F_GETLK - 测试lock所表示的锁是否可加。
若可加则将lock.l_type置为F_UNLCK，
否则通过lock返回当前锁的信息。

F_SETLK - 设置锁定状态为lock.l_type，
成功返回0，失败返回-1。
若因其它进程持有锁而导致失败，
则errno为EACCES或EAGAIN。

F_SETLKW - 设置锁定状态为lock.l_type，
成功返回0，否则一直等待，
除非被信号打断返回-1。

1) 既可以锁定整个文件，也可以锁定特定区域。

2) 读锁(共享锁)、写锁(独占锁/排它锁)、解锁。

范例：lock1.c

#include 
#include 
#include 
#include 
// 加读锁
int rlock (int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, wait ? F_SETLKW : F_SETLK,&lock);
}
// 加写锁
int wlock (int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, wait ? F_SETLKW : F_SETLK,&lock);}
// 解锁
int ulock (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, F_SETLK, &lock);
}
int main (void) {
    printf ("进程标识(PID)：%d\n", getpid ());
    int fd = open ("lock.txt",
        O_RDWR | O_CREAT | O_TRUNC, 0664);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    const char* text = "ABCDEFGHIJKLMNOPQR";
    if (write (fd, text,
        strlen (text) * sizeof (text[0])) == -1) {
        perror ("write");
        return -1;
    }
    // 对EFGH加读锁
    printf ("对EFGH加读锁");
    if (rlock (fd, 4, 4, 0) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    printf ("成功！\n");
    // 对MNOP加写锁
    printf ("对MNOP加写锁");
    if (wlock (fd, 12, 4, 0) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    printf ("成功！\n");
    printf ("按<回车>，解锁MN...");
    getchar ();
    // 解锁MN
    ulock (fd, 12, 2);
    printf ("按<回车>，解锁EFGH...");
    getchar ();
    // 解锁EFGH
    ulock (fd, 4, 4);
    close (fd);
    return 0;
}

图片展示

图示：rwlock.bmp

图示: flock.bmp

3) 文件描述符被关闭(进程结束)时，自动解锁。

4) 劝谏锁(协议锁)、强制锁。

范例：lock2.c

#include 
#include 
#include 
#include 
// 打印锁
void plock (struct flock lock) {
    if (lock.l_type == F_UNLCK)
        printf ("没有锁。\n");
    else {
        printf ("%d进程", lock.l_pid);
        switch (lock.l_whence) {
            case SEEK_SET:
                printf ("在距文件头");
                break;
            case SEEK_CUR:
                printf ("在距当前位置");
                break;
            case SEEK_END:
                printf ("在距文件尾");
                break;
        }
        printf ("%ld字节处，为%ld字节加了",
            lock.l_start, lock.l_len);
        switch (lock.l_type) {
            case F_RDLCK:
                printf ("读锁。\n");
                break;
            case F_WRLCK:
                printf ("写锁。\n");
                break;
        }
    }
}
// 读锁测试
int rtest (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    if (fcntl (fd, F_GETLK, &lock) == -1)
        return -1;
    plock (lock);
    return 0;
}
// 写锁测试
int wtest (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    if (fcntl (fd, F_GETLK, &lock) == -1)
        return -1;
    plock (lock);
    return 0;
}
// 加读锁
int rlock (int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, wait ? F_SETLKW : F_SETLK,&lock);
}
// 加写锁
int wlock (int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, wait ? F_SETLKW : F_SETLK,&lock);}
// 解锁
int ulock (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, F_SETLK, &lock);
}
int main (void) {
    int fd = open ("lock.txt", O_RDWR);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    // 对CDEF做读锁测试
    printf ("对CDEF做读锁测试。");
    if (rtest (fd, 2, 4) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    // 对CDEF加读锁
    printf ("对CDEF加读锁");
    if (rlock (fd, 2, 4, 0) == -1)
        printf ("失败：%m\n");
    else {
        printf ("成功！\n");
        ulock (fd, 2, 4);
    }
    // 对CDEF做写锁测试
    printf ("对CDEF做写锁测试。");
    if (wtest (fd, 2, 4) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    // 对CDEF加写锁
    printf ("对CDEF加写锁");
    if (wlock (fd, 2, 4, 0) == -1)
        printf ("失败：%m\n");
    else {
        printf ("成功！\n");
        ulock (fd, 2, 4);
    }
    // 对KLMN做读锁测试
    printf ("对KLMN做读锁测试。");
    if (rtest (fd, 10, 4) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    // 对KLMN加读锁
    printf ("对KLMN加读锁");
    if (rlock (fd, 10, 4, 0) == -1)
        printf ("失败：%m\n");
    else {
        printf ("成功！\n");
        ulock (fd, 10, 4);
    }
    // 对KLMN做写锁测试
    printf ("对KLMN做写锁测试。");
    if (wtest (fd, 10, 4) == -1) {
        printf ("失败：%m\n");
        return -1;
    }
    // 对KLMN加写锁
    printf ("对KLMN加写锁");
    if (wlock (fd, 10, 4, 0) == -1)
        printf ("失败：%m\n");
    else {
        printf ("成功！\n");
        ulock (fd, 10, 4);
    }
    printf ("等待KLMN上的写锁被解除...\n");
    // 对KLMN加写锁
    printf ("对KLMN加写锁");
    if (wlock (fd, 10, 4, 1) == -1)
        printf ("失败：%m\n");
    else {
        printf ("成功！\n");
        ulock (fd, 10, 4);
    }
    close (fd);
    return 0;
}

5) 文件锁仅在不同进程间起作用。

6) 通过锁同步多个进程对同一个文件的读写访问。

范例： wlock.c

#include 
#include 
#include 
#include 
#include 
// 写锁测试
// 返回
//  1 - 可加写锁
//  0 - 不可加写锁
// -1 - 系统错误
int wtest (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    if (fcntl (fd, F_GETLK, &lock) == -1)
        return -1;
    if (lock.l_type == F_UNLCK)
        return 1;
    return 0;
}
// 加写锁
int wlock (int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, wait ? F_SETLKW : F_SETLK,&lock);
}
// 解锁
int ulock (int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl (fd, F_SETLK, &lock);
}
int main (int argc, char* argv[]) {
    if (argc < 2) {
        fprintf (stderr,"用法：%s <字符串>\n",argv[0]);
        return -1;
    }
    int fd = open ("wlock.txt",
        O_WRONLY | O_CREAT | O_APPEND, 0664);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    /*
    int unlock = 0;
    do {
        if ((unlock = wtest (fd, 0, 0)) == -1) {
            perror ("wtest");
            return -1;
        }
        if (! unlock) {
            printf ("该文件已被锁定，稍后再试...\n");
            // 空闲处理
            // ...
        }
    }   while (! unlock);
    if (wlock (fd, 0, 0, 0) == -1) {
        perror ("wlock");
        return -1;
    }
    */
    while (wlock (fd, 0, 0, 0) == -1) {
        if (errno != EACCES && errno != EAGAIN) {
            perror ("wlock");
            return -1;
        }
        printf ("该文件已被锁定，稍后再试...\n");
        // 空闲处理
        // ...
    }
    /*
    if (wlock (fd, 0, 0, 1) == -1) {
        perror ("wlock");
        return -1;
    }
    */
    size_t i, len = strlen (argv[1]);
    for (i = 0; i < len; ++i) {
        if (write (fd, &argv[1][i],
            sizeof (argv[1][i])) == -1) {
            perror ("write");
            return -1;
        }
        sleep (1);
    }
    if (ulock (fd, 0, 0) == -1) {
        perror ("ulock");
        return -1;
    }
    close (fd);
    return 0;
}

范例：rlock.c

#include 
#include 
#include 
#include 
#include 
int main (int argc, char* argv[]) {
    int fd = open ("wlock.txt", O_RDONLY, 0664);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    char buf[1024];
    ssize_t readed;
    while ((readed = read (fd, buf, sizeof (buf)))>0)
        write (STDOUT_FILENO, buf, readed);
    if (readed == -1) {
        perror ("read");
        return -1;
    }
    close (fd);
    return 0;
}

执行结果

# wlock 非常时刻科技 | # wlock 有限公司
wlock.txt
<乱码>

# wlock 非常时刻科技 -l | # wlock 有限公司 -l
wlock.txt
非常时刻奋斗奋斗

-----------------------------------------

# wlock 非常时刻奋斗奋斗 | # rlock
<乱码>

# wlock 非常时刻奋斗奋斗 -l | # rlock -l
非常时刻奋斗奋斗

三、 stat和fstat以及lstat

---

获取文件属性。

函数说明

#include  

int stat (
    const char*  path, // 文件路径
    struct stat* buf   // 文件属性
);

int fstat (
    int          fd, // 文件描述符
    struct stat* buf // 文件属性
);

int lstat (
    const char*  path, // 文件路径
    struct stat* buf   // 文件属性
);

成功返回0，失败返回-1。

stat函数跟踪软链接，lstat函数不跟踪软链接。

struct stat {
dev_t st_dev; // 设备ID
ino_t st_ino; // i节点号
mode_t st_mode; // 文件类型和权限
nlink_t st_nlink; // 硬链接数
uid_t st_uid; // 属主ID
gid_t st_gid; // 属组ID
dev_t st_rdev; // 特殊设备ID
off_t st_size; // 总字节数
blksize_t st_blksize; // I/O块字节数
blkcnt_t st_blocks; // 占用块(512字节)数
time_t st_atime; // 最后访问时间
time_t st_mtime; // 最后修改时间
time_t st_ctime; // 最后状态改变时间
};

st_mode(0TTSUGO)为以下值的位或：

S_IFDIR           - 目录        \
S_IFREG           - 普通文件     |
S_IFLNK           - 软链接       |
S_IFBLK           - 块设备       > TT (S_IFMT)
S_IFCHR           - 字符设备     |
S_IFSOCK          - Unix域套接字 |
S_IFIFO           - 有名管道    /
--------------------------------
S_ISUID           - 设置用户ID  \
S_ISGID           - 设置组ID     > S
S_ISVTX           - 粘滞        /
--------------------------------
S_IRUSR(S_IREAD)  - 属主可读    \
S_IWUSR(S_IWRITE) - 属主可写     > U (S_IRWXU)
S_IXUSR(S_IEXEC)  - 属主可执行  /
--------------------------------
S_IRGRP           - 属组可读    \
S_IWGRP           - 属组可写     > G (S_IRWXG)
S_IXGRP           - 属组可执行  /
--------------------------------
S_IROTH           - 其它可读    \
S_IWOTH           - 其它可写     > O (S_IRWXO)
S_IXOTH           - 其它可执行  /

其它说明

1.有关S_ISUID/S_ISGID/S_ISVTX的说明

1) 具有S_ISUID/S_ISGID位的可执行文件，
其有效用户ID/有效组ID，
并不取自由其父进程(比如登录shell)所决定的，
实际用户ID/实际组ID，
而是取自该可执行文件的属主ID/属组ID。
如：/usr/bin/passwd

2) 具有S_ISUID位的目录，
其中的文件或目录除root外，
只有其属主可以删除。

3) 具有S_ISGID位的目录，
在该目录下所创建的文件，继承该目录的属组ID，
而非其创建者进程的有效组ID。

4) 具有S_ISVTX位的可执行文件，
在其首次执行并结束后，
其代码区将被连续地保存在磁盘交换区中，
而一般磁盘文件中的数据块是离散存放的。
因此，下次执行该程序可以获得较快的载入速度。
现代Unix系统大都采用快速文件系统，
已不再需要这种技术。

5) 具有S_ISVTX位的目录，
只有对该目录具有写权限的用户，
在满足下列条件之一的情况下，
才能删除或更名该目录下的文件或目录：

A. 拥有此文件；
B. 拥有此目录；
C. 是超级用户。

如：/tmp

任何用户都可在该目录下创建文件，
任何用户对该目录都享有读/写/执行权限，
但除root以外的任何用户在目录下，
都只能删除或更名属于自己的文件。

辅助分析st_mode

2. 常用以下宏辅助分析st_mode

S_ISDIR() - 是否目录
S_ISREG() - 是否普通文件
S_ISLNK() - 是否软链接
S_ISBLK() - 是否块设备
S_ISCHR() - 是否字符设备
S_ISSOCK() - 是否Unix域套接字
S_ISFIFO() - 是否有名管道

范例：stat.c

#include 
#include 
#include 
#include 
const char* mtos (mode_t m) {
    static char s[11];
    if (S_ISDIR (m))
        strcpy (s, "d");
    else
    if (S_ISLNK (m))
        strcpy (s, "l");
    else
    if (S_ISBLK (m))
        strcpy (s, "b");
    else
    if (S_ISCHR (m))
        strcpy (s, "c");
    else
    if (S_ISSOCK (m))
        strcpy (s, "s");
    else
    if (S_ISFIFO (m))
        strcpy (s, "p");
    else
        strcpy (s, "-");
    strcat (s, m & S_IRUSR ? "r" : "-");
    strcat (s, m & S_IWUSR ? "w" : "-");
    strcat (s, m & S_IXUSR ? "x" : "-");
    strcat (s, m & S_IRGRP ? "r" : "-");
    strcat (s, m & S_IWGRP ? "w" : "-");
    strcat (s, m & S_IXGRP ? "x" : "-");
    strcat (s, m & S_IROTH ? "r" : "-");
    strcat (s, m & S_IWOTH ? "w" : "-");
    strcat (s, m & S_IXOTH ? "x" : "-");
    if (m & S_ISUID)
        s[3] = (s[3] == 'x' ? 's' : 'S');
    if (m & S_ISGID)
        s[6] = (s[6] == 'x' ? 's' : 'S');
    if (m & S_ISVTX)
        s[9] = (s[9] == 'x' ? 't' : 'T');
    return s;
}
const char* ttos (time_t t) {
    static char s[20];
    struct tm* lt = localtime (&t);
    sprintf (s, "%04d-%02d-%02d %02d:%02d:%02d",
        lt->tm_year + 1900,
        lt->tm_mon + 1,
        lt->tm_mday,
        lt->tm_hour,
        lt->tm_min,
        lt->tm_sec);
    return s;
}
int main (int argc, char* argv[]) {
    if (argc < 2)
        goto usage;
    struct stat st;
    if (argc < 3) {
        if (stat (argv[1], &st) == -1) {
            perror ("stat");
            return -1;
        }
    }
    else if (! strcmp (argv[2], "-l")) {
        if (lstat (argv[1], &st) == -1) {
            perror ("lstat");
            return -1;
        }
    }
    else
        goto usage;
    printf ("           设备ID：%lld\n", st.st_dev);
    printf ("          i节点号：%ld\n", st.st_ino);
    printf ("             模式：%s\n",
        mtos (st.st_mode));
    printf ("         硬链接数：%u\n", st.st_nlink);
    printf ("           属主ID：%u\n", st.st_uid);
    printf ("           属组ID：%u\n", st.st_gid);
    printf ("       特殊设备ID：%lld\n", st.st_rdev);
    printf ("         总字节数：%ld\n", st.st_size);
    printf ("      I/O块字节数：%ld\n", st.st_blksize);
    printf ("占用块(512字节)数：%ld\n", st.st_blocks);
    printf ("     最后访问时间：%s\n",
        ttos (st.st_atime));
    printf ("     最后修改时间：%s\n",
        ttos (st.st_mtime));
    printf (" 最后状态改变时间：%s\n",
        ttos (st.st_ctime));
    return 0;
usage:
    fprintf (stderr, "用法：%s <文件> [-l]\n",argv[0]);
    return -1;
}

四、 access

---

#include 

int access (
    const char* pathname, // 文件路径
    int         mode      // 访问模式
);

1. 按实际用户ID和实际组ID(而非有效用户ID和有效组ID)，
   进行访问模式测试。

2. 成功返回0，失败返回-1。

3. mode取R_OK/W_OK/X_OK的位或，
   测试调用进程对该文件，
   是否可读/可写/可执行，
   或者取F_OK，测试该文件是否存在。

范例：access.c

#include 
#include 
int main (int argc, char* argv[]) {
    if (argc < 2) {
        fprintf (stderr, "用法：%s <文件>\n", argv[0]);
        return -1;
    }
    printf ("文件%s", argv[1]);
    if (access (argv[1], F_OK) == -1)
        printf ("不存在(%m)。\n");
    else {
        if (access (argv[1], R_OK) == -1)
            printf ("不可读(%m)，");
        else
            printf ("可读，");
        if (access (argv[1], W_OK) == -1)
            printf ("不可写(%m)，");
        else
            printf ("可写，");
        if (access (argv[1], X_OK) == -1)
            printf ("不可执行(%m)。\n");
        else
            printf ("可执行。\n");
    }
    return 0;
}

五、 umask

---

可以用umask命令查看/修改当前shell的文件权限屏蔽字：

函数说明

# umask
0022

# umask 0033
# umask
0033

#include 

mode_t umask (
    mode_t cmask // 屏蔽字
);

参数说明

1. 为进程设置文件权限屏蔽字，并返回以前的值，
   此函数永远成功。

2. cmask由9个权限宏位或组成(直接写八进制整数形式亦可，
   如022 - 屏蔽属组和其它用户的写权限)：

---

S_IRUSR(S_IREAD) - 属主可读
S_IWUSR(S_IWRITE) - 属主可写
S_IXUSR(S_IEXEC) - 属主可执行

---

S_IRGRP - 属组可读
S_IWGRP - 属组可写
S_IXGRP - 属组可执行

---

S_IROTH - 其它可读
S_IWOTH - 其它可写
S_IXOTH - 其它可执行

---

3 设上屏蔽字以后，此进程所创建的文件，
都不会有屏蔽字所包含的权限。

范例：umask.c

#include 
#include 
#include 
#include 
int main (void) {
    /*
    mode_t old = umask (
        S_IWUSR | S_IXUSR |
        S_IWGRP | S_IXGRP |
        S_IWOTH | S_IXOTH);*/
    mode_t old = umask (0333);
    int fd = open ("umask.txt",
        O_RDWR | O_CREAT | O_TRUNC, 0777);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    close (fd);
    umask (old);
    return 0;
}

六、 chmod和fchmod

---

修改文件的权限。

函数说明

#include 

int chmod (
    const char* path, // 文件路径
    mode_t      mode  // 文件权限
);

int fchmod (
    int    fd,  // 文件路径
    mode_t mode // 文件权限
);

成功返回0，失败返回-1。

参数说明

mode为以下值的位或(直接写八进制整数形式亦可，
如07654 - rwSr-sr-T)：

S_ISUID - 设置用户ID
S_ISGID - 设置组ID
S_ISVTX - 粘滞

---

S_IRUSR(S_IREAD) - 属主可读
S_IWUSR(S_IWRITE) - 属主可写
S_IXUSR(S_IEXEC) - 属主可执行

---

S_IRGRP - 属组可读
S_IWGRP - 属组可写
S_IXGRP - 属组可执行

---

S_IROTH - 其它可读
S_IWOTH - 其它可写
S_IXOTH - 其它可执行

范例：chmod.c

#include 
#include 
#include 
#include 
int main (void) {
    int fd = open ("chmod.txt",
        O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    /*
    if (fchmod (fd, 07654) == -1) {// rwSr-sr-T
    */
    if (fchmod (fd,
        S_ISUID | S_ISGID | S_ISVTX |
        S_IRUSR | S_IWUSR |
        S_IRGRP | S_IXGRP |
        S_IROTH) == -1) {
        perror ("fchmod");
        return -1;
    }
    close (fd);
    return 0;
}

七、 chown和fchown以及lchown

---

函数说明

# chown : 

修改文件的属主和属组。

#include 

int chown (
    const char* path,  // 文件路径
    uid_t       owner, // 属主ID
    gid_t       group  // 属组ID
);


int fchown (
    int   fildes, // 文件描述符
    uid_t owner,  // 属主ID
    gid_t group   // 属组ID
);

int lchown (
    const char* path,  // 文件路径(不跟踪软链接)
    uid_t       owner, // 属主ID
    gid_t       group  // 属组ID
);

成功返回0，失败返回-1。

附加说明

注意：

1. 属主和属组ID取-1表示不修改。

2. 超级用户进程可以修改文件的属主和属组，
   普通进程必须拥有该文件才可以修改其属主和属组。

八、 truncate和ftruncate

---

修改文件的长度，截短丢弃，加长添零。

函数说明

#include 

int truncate (
    const char* path,  // 文件路径
    off_t       length // 文件长度
);

int ftruncate (
    int   fd,    // 文件描述符
    off_t length // 文件长度
);

成功返回0，失败返回-1。

范例：trunc.c

#include 
#include 
#include 
#include 
#include 
int main (void) {
    const char* text = "Hello, World !";
    size_t size = (strlen (text) + 1) *
        sizeof (text[0]);
    int fd = open ("trunc.txt",
        O_RDWR | O_CREAT | O_TRUNC, 0664);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    if (ftruncate (fd, size) == -1) {
        perror ("ftruncate");
        return -1;
    }
    void* map = mmap (NULL, size, PROT_READ|PROT_WRITE,
        MAP_SHARED/*MAP_PRIVATE*/, fd, 0);
    if (map == MAP_FAILED) {
        perror ("mmap");
        return -1;
    }
    memcpy (map, text, size);
    printf ("%s\n", (char*)map);
    munmap (map, size);
    close (fd);
    return 0;
}

范例：mmap.c

#include 
#include 
#include 
#include 
#include 
int main (void) {
    int fd = open ("trunc.txt", O_RDONLY);
    if (fd == -1) {
        perror ("open");
        return -1;
    }
    struct stat st;
    if (fstat (fd, &st) == -1) {
        perror ("fstat");
        return -1;
    }
    void* map = mmap (NULL, st.st_size, PROT_READ,
        MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) {
        perror ("mmap");
        return -1;
    }
    printf ("%s\n", (char*)map);
    munmap (map, st.st_size);
    close (fd);
    return 0;
}

附加说明

注意：对于文件映射，
私有映射(MAP_PRIVATE)将数据写到缓冲区而非文件中，
只有自己可以访问。
而对于内存映射，
私有(MAP_PRIVATE)和公有(MAP_SHARED)没有区别，
都是仅自己可以访问。

九、 link和unlink 、 remove和rename

---

link: 创建文件的硬链接(目录条目)。

unlink: 删除文件的硬链接(目录条目)。
只有当文件的硬链接数降为0时，文件才会真正被删除。
若该文件正在被某个进程打开，
其内容直到该文件被关闭才会被真正删除。

remove: 对文件同unlink，
对目录同rmdir (不能删非空目录)。

rename: 修改文件/目录名。

#include 

int link (
    const char* path1, // 文件路径
    const char* path2  // 链接路径
);

int unlink (
    const char* path // 链接路径
);

#include 

int remove (
    const char* pathname // 文件/目录路径
);

int rename (
    const char* old, // 原路径名
    const char* new  // 新路径名
);

成功返回0，失败返回-1。

注意：硬链接只是一个文件名，即目录中的一个条目。
软链接则是一个独立的文件，
其内容是另一个文件的路径信息。

十、 symlink / readlink

---

symlink: 创建软链接。目标文件可以不存在，
也可以位于另一个文件系统中。

readlink: 获取软链接文件本身(而非其目标)的内容。
open不能打开软链接文件本身。

#include 

int symlink (
    const char* oldpath, // 文件路径(可以不存在)
    const char* newpath  // 链接路径
);

成功返回0，失败返回-1。

ssize_t readlink (
    const char* restrict path,   // 软链接文件路径
    char* restrict       buf,    // 缓冲区
    size_t               bufsize // 缓冲区大小
);

成功返回实际拷入缓冲区buf中软链接文件内容的字节数，
失败返回-1。

范例：slink.c

#include 
#include 
#include 
#include 
int main (int argc, char* argv[]) {
    if (argc < 3) {
        fprintf (stderr,
            "用法：%s <文件> <软链接>\n", argv[0]);
        return -1;
    }
    if (symlink (argv[1], argv[2]) == -1) {
        perror ("symlink");
        return -1;
    }
    char slink[PATH_MAX+1] = {};
    if (readlink (argv[2], slink,
        sizeof (slink) - sizeof (slink[0])) == -1) {
        perror ("readlink");
        return -1;
    }
    printf ("%s是%s的软链接。\n", argv[2], slink);
    return 0;
}

十一、 mkdir / rmdir

---

mkdir: 创建一个空目录。

rmdir: 删除一个空目录。

#include 

int mkdir (
    const char* path, // 目录路径
    mode_t      mode  // 访问权限，
                      // 目录的执行权限(x)表示可进入
);

#include 

int rmdir (
    const char* path // 目录路径
);

成功返回0，失败返回-1。

十二、 chdir / fchdir / getcwd

---

chdir/fchdir: 更改当前工作目录。
工作目录是进程的属性，只影响调用进程本身。

getcwd: 获取当前工作目录。

#include 

int chdir (
    const char* path // 工作目录路径
);

int fchdir (
    int fildes // 工作目录描述符(由open函数返回)
);

//成功返回0，失败返回-1。

char* getcwd (
    char*  buf, // 缓冲区
    size_t size // 缓冲区大小
);

成功返回当前工作目录字符串指针，失败返回NULL。

十三、 opendir / fdopendir / closedir / readdir / rewinddir / telldir / seekdir

---

基本说明

opendir/fdopendir: 打开目录流。

closedir: 关闭目录流。

readdir: 读取目录流。

rewinddir: 复位目录流。

telldir: 获取目录流当前位置。

seekdir: 设置目录流当前位置。

函数说明

#include 
#include 

DIR* opendir (
    const char* name // 目录路径
);

DIR* fdopendir (
    int fd // 目录描述符(由open函数返回)
);

成功返回目录流指针，失败返回NULL。

int closedir (
    DIR* dirp // 目录流指针
);

成功返回0，失败返回-1。

struct dirent* readdir (
    DIR* dirp // 目录流指针
);

成功返回下一个目录条目结构体的指针，
到达目录尾(不置errno)或失败(设置errno)返回NULL。

struct dirent {
    ino_t          d_ino;       // i节点号
    off_t          d_off;       // 下一条目的偏移量
                                // 注意是磁盘偏移量
                                // 而非内存地址偏移
    unsigned short d_reclen;    // 记录长度
    unsigned char  d_type;      // 文件类型
    char           d_name[256]; // 文件名
};

参数说明

d_type取值：

DT_DIR - 目录
DT_REG - 普通文件
DT_LNK - 软链接
DT_BLK - 块设备
DT_CHR - 字符设备
DT_SOCK - Unix域套接字
DT_FIFO - 有名管道
DT_UNKNOWN - 未知

图示：de.bmp

范例：list.c

练习：打印给定路径下的目录树。

代码：tree.c

void rewinddir (
DIR* dirp // 目录流指针
);

long telldir (
DIR* dirp // 目录流指针
);

成功返回目录流的当前位置，失败返回-1。

void seekdir (
DIR* dirp, // 目录流指针
long offset // 位置偏移量
);

目录流：

            +-----------------------+           +-----------------------+
            |                       v           |                       v
+-------+---|---+-----+-------+     +-------+---|---+-----+-------+     +-------
| d_ino | d_off | ... | a.txt | ... | d_ino | d_off | ... | b.txt | ... | d_ino
+-------+-------+-----+-------+     +-------+-------+-----+-------+     +-------
^                                   ^
|          -- readdir() ->          |

范例：seek.c

#include 
#include 
#include 
int main (int argc, char* argv[]) {
    if (argc < 2) {
        fprintf (stderr, "用法：%s <目录>\n", argv[0]);
        return -1;
    }
    DIR* dp = opendir (argv[1]);
    if (! dp) {
        perror ("opendir");
        return -1;
    }
    seekdir (dp, 686782084);
    rewinddir (dp);
    long offset = telldir (dp);
    if (offset == -1) {
        perror ("telldir");
        return -1;
    }
    errno = 0;
    struct dirent* de;
    for (de = readdir (dp); de; de = readdir (dp)) {
        printf ("[%010ld %010ld] ", offset, de->d_off);
        switch (de->d_type) {
            case DT_DIR:
                printf ("        目录：");
                break;
            case DT_REG:
                printf ("    普通文件：");
                break;
            case DT_LNK:
                printf ("      软链接：");
                break;
            case DT_BLK:
                printf ("      块设备：");
                break;
            case DT_CHR:
                printf ("    字符设备：");
                break;
            case DT_SOCK:
                printf ("Unix域套接字：");
                break;
            case DT_FIFO:
                printf ("    有名管道：");
                break;
            default:
                printf ("        未知：");
                break;
        }
        printf ("%s\n", de->d_name);
        if ((offset = telldir (dp)) == -1) {
            perror ("telldir");
            return -1;
        }
    }
    if (errno) {
        perror ("readdir");
        return -1;
    }
    closedir (dp);
    return 0;
}