linux系统编程01-文件系统

挡缭发表于 2025-9-17 00:26:28

目录

[*]介绍
[*]一、目录和文件

[*]1. 获取文件的属性： stat
[*]2.文件属性
[*]3.umask
[*]4.文件权限管理
[*]5.粘住位
[*]6.文件系统：FAT、UFS
[*]7.硬链接，符号链接
[*]9. 文件目录解析： glob
[*]例子：实现指令 du

[*]二、系统数据文件和信息

[*]1. 用户信息：/etc/passwd
[*]2. 组信息： /etc/group
[*]3. 加密： /etc/shadow
[*]4. 时间函数

[*]三、进程环境

[*]1. main函数
[*]2. 进程的终止

[*]exit、_exit、_Exit
[*]钩子函数

[*]3. 命令行参数分析
[*]4. 环境变量
[*]5. C程序的存储空间和库
[*]6. setjmp\longjmp
[*]7. 资源获取及控制

介绍

类ls的实现，如myls， -l -a -i -n
一、目录和文件
二、系统数据文件和信息
三、进程环境
参考书籍：apue\csapp
一、目录和文件

1. 获取文件的属性： stat

##include <sys/types.h>
##include <sys/stat.h>
##include <unistd.h>

int stat(const char *pathname, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);
int lstat(const char *pathname, struct stat *statbuf);

[*]参数：路径，结构体地址，用来填充文件信息
[*]返回值：成功0，失败-1
[*]区分：

[*]stat 用路径获取文件属性，面对符号链接时获取的是目标文件的属性
[*]fstat 用 fd 获取文件属性，同上
[*]lstat 用 fd 获取文件属性，面对符号链接时，获取的符号链接的属性

struct stat 的内容： man 2 stat 查看

主要包括 inode\st_size\uid\gid。命令 ls 和 stat 的内容都是从中拿取的。
例子：用 stat 函数统计文件大小
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<sys/types.h>
##include<sys/stat.h>
##include<unistd.h>

static off_t flen(const char *FNAME)
{
struct stat statres;
if(stat(FNAME, &statres) < 0)
{
   perror("stat()");
   exit(1);
}
return statres.st_size;
}

int main(int argc, char **argv)
{
if(argc < 2)
{
   fprintf(stderr, "Usage():...\n");
   exit(1);
}

printf("%lld\n",(long long)flen(argv));
exit(0);
}运行结果：

注意： st_size 的属性是 off_t ，大小取决于机器的架构，有的是longlong，有的是int。所以 1. 可以强转为longlong 2.在 makefile 里加 CFLAGS += -D_FILE_OFFSET_BITS=64
文件的 st_size 只是一个文件属性，而 blocks 才是真正占用的磁盘大小
示例代码
##include<stdio.h>
##include<stdlib.h>
##include<sys/types.h>
##include<sys/stat.h>
##include<unistd.h>
##include<fcntl.h>

int main(int argc, char ** argv)
{
if(argc < 2)
{
   fprintf(stderr, "Usagne:...\n");
   exit(1);
}
int fd;
fd = open(argv, O_WRONLY|O_CREAT|O_TRUNC, 0600);
if(fd < 0)
{
   perror("open()");
   exit(1);
}
if(lseek(fd, 5*1024*1024*1024LL-1LL, SEEK_SET) < 0)
{
   perror("lseek()");
   exit(1);
}
}运行结果：

程序解释：

[*]所有的常量都有单位，没写单位则默认， lseek(fd, 5*1024*1024*1024LL-1LL, SEEK_SET) 此处如果不加上 LL 则默认是 int ，那么就会爆
[*]运行结果说明：s

[*]size为5G大小的文件实际占用的磁盘大小为4KB。
[*]cp 发现是空洞内容就不会进行实际的 write 所以虽然两个文件的 size 一样，但是第二个文件的 blocks 为0，实际上不占用磁盘空间。因此出现 siz=5G但不占用磁盘空间。
[*]二者都表明unix中 size 只是一个文件属性，而不是表示文件大小，这一点要和 windows区分开。

[*]当前内核运行结果：

名词解析一般大小size文件的大小，是文件的属性/扇区磁盘划分的单位，存储的最小单元512B（0.5KB）块block文件io的最小单元4096B（4KB = 8*扇区）即使存储1KB文件，也要占用一个块（4KB），读取时也是一个块一个块地读（cache）
https://blog.csdn.net/daiyudong2020/article/details/53897775
因此，对于 flen.c ，虽然只有496B，但是也要占用4KB的磁盘空间。（ stat 的blocks的单位是扇区大小，可以推测 blocks ≥ 8）
2.文件属性

stat函数中 st_mode ：一个16位的位图，用于表示文件类型，文件访问权限，以及特殊权限位。
16 ⇒ 7种文件类型(3bit) + 文件访问权限(rwx*3=9bit) + 特殊权限位(uid+gid+sticky=3) = 15
七种文件类型： dcb-lsp 目录、字符设备、块设备、常规文件、符号链接、网络socket、管道
下面函数是使用宏实现的，判断文件类型，函数返回真假以表明是否属于这种文件类型

例子：写程序判断文件类型
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<sys/types.h>
##include<sys/stat.h>
##include<unistd.h>
##include<fcntl.h>

static char* ftype(const char *FNAME)
{
struct stat statres;
if(stat(FNAME, &statres) < 0)
{
   perror("stat()");
   exit(1);
}

if(S_ISREG(statres.st_mode))
   return "regular file";
else
   return "not regular file";
}

int main(int argc, char **argv)
{
if(argc < 2)
{
   fprintf(stderr, "Usage:...\n");
   exit(1);
}

printf("%s\n",ftype(argv));

exit(0);
}运行结果：

3.umask

作用：避免产生权限过松的文件
文件权限 = 0664 & ~umask
命令 umask 是由函数 umask 封装而成，程序中可以使用函数 umask 来改变umask
4.文件权限管理

命令 chmod

[*]chmod 666 file_name ：直接改变文件权限
[*]chomod u\g\o+r\w\x ：加减文件权限
函数 chomod 用法类似：
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);5.粘住位

现在用的越来越少，仅做了解
作用：一开始是为了让可执行文件的装载内容在内存中保留，下次调用的时候装载得更快，但现在已经有page cache机制，所以不那么常用
现在一般是给目录设置t位，如 /tmp

6.文件系统：FAT、UFS

FAT文件系统：

静态单链表可以写为：【算法基础课里的写法】
struct node{
int next; //下一个的下标
char data; //数据
}nodes;也可以写为上述的形式。
可见：FAT文件系统的承载能力取决于N，惧怕大文件；而且由于是单链表，单向索引，所以取数据不灵活。
UFS文件系统：

[*]inode 是一个结构体，存储文件相关信息（stat命令就是从这里取的），和一个指针数组（12+3），分别指向11个直接数据块，1个一、二、三级间接数据，存的是数据块的物理地址。所以一个文件对应一个 inode ， inode 的指针数组整合了所有数据块，没有链式结构了，并且不怕大文件了。
[*]inode位图和块位图用来表示某一个 inode 或者某一个块有没有被使用

[*]目录文件就是一个文件，没有什么特殊
[*]只不过它的文件块中存储的数据是目录项 inode - filename 的对应关系
[*]路径解析：

[*]前提：知道 / 目录的数据块，这是周知的，操作系统初始化时就做好，在 inode位图里的第二位。
[*]解析 /tmp/out ：根据 / 的inode得到 / 目录文件的数据块，里面的内容是数据项，包含 out文件名和它对应的inode，在根据 out文件的inode，就可以得到out文件的数据块。

7.硬链接，符号链接

软硬链接：
ln 内部用 link函数实现，对应的是 unlink 函数【 man 2 link/unlink】
unlink实现匿名函数: open 后再 unlink
unlink 封装出命令 rm 和库函数（ man 3 ）函数 remove 【unlink是系统调用，移植性不够好】
asd
其他：
文件移动和重命名： rename → 封装出命令 mv
时间： utime
用以更改 Acess time 和 modify time
9. 文件目录解析： glob

[*]创建删除： mkdir rmdir
[*]更改路径： chdir \ fchdir → 封装出命令 mv
[*]获取当前路径： getcwd → 封装出命令 pwd
关于main的命令行参数：
示例代码：
##include<stdio.h>
##include<stdlib.h>

int main(int argc, char **argv)
{
int i;
for(i=0; argv != NULL; i++)
   puts(argv);

exit(0);
}运行结果：

几点说明：

[*]argv 数组是以 NULL 结尾的
[*]终端执行 ./main *c 是可以匹配通配符，是因为 main 函数的参数支持通配符匹配吗，并不是。是因为 *.c 是经过终端shell 再到程序的，是shell把通配符匹配掉了
读取和分析目录：
##include <glob.h>
glob();

//把目录操作视为流操作
opendir();
closedir();
readdir();
seekdir();
telldir();glob函数：
int glob(const char *pattern, int flags,
            int (*errfunc) (const char *epath, int eerrno),
            glob_t *pglob);

[*]参数：

[*]pattern 模式串，支持通配符
[*]flags 标志选项： GLOB_NOCHECK GLOB_NOSORT GLOB_APPEND 等
[*]errfunc 函数指针：用来处理错误信息
[*]pglob 结构体，反填结果

[*]gl_pathc 和 gl_pathv 的结构和用法和 argc 和 argv 一样

[*]返回值：成功返回0，失败返回1
例子：列出 /etc 目录下a开头的.conf文件
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<glob.h>

##define PAT "/etc/a*.conf"

int main()
{
int i,err;
glob_t globres;

err = glob(PAT, 0, NULL, &globres);
if(err)
{
   printf("Error code = %d\n", err);
   exit(1);
}

for(i=0; i < globres.gl_pathc; i++)
   puts(globres.gl_pathv);

exit(0);
}运行结果：

说明

[*]为什么 glob 出错时不用 perror ，因为 glob 不会置 errno
[*]错误处理函数

目录流函数：
##include <sys/types.h>
##include <dirent.h>

DIR *opendir(const char *name);
DIR *fdopendir(int fd);
int closedir(DIR *dirp);

struct dirent *readdir(DIR *dirp);可见和流操作很像，只不过捏的不是 FILE 而是 DIR

例子：列出 /etc 目录下所有文件
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<sys/types.h>
##include<dirent.h>

##define PAT "/etc"

int main()
{
DIR * dp;
struct dirent *cur;

dp = opendir(PAT);
if(dp == NULL)
{
   //会置errno
   perror("opendir()");
   exit(1);
}

while((cur = readdir(dp)) != NULL)
   puts(cur->d_name);

closedir(dp);

exit(0);
}运行结果：

例子：实现指令 du

指令 du 以KB的形式返回文件或目录所占用的大小
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<sys/types.h>
##include<sys/stat.h>
##include<unistd.h>
##include<glob.h>
##include<string.h>

##define PATHSIZE 1024

static int path_noloop(const char *path)
{
char *pos;
pos = strrchr(path, '/');

if(pos == NULL)
   exit(1);
if( strcmp(pos+1, ".") == 0 || strcmp(pos+1, "..") == 0)
   return 0;

return 1;
}

static int64_t mydu(const char *path)
{
struct stat statres;
glob_t globres;
int err,i;
int64_t sum;
char nextpath;

//使用lstat
if(lstat(path, &statres) < 0)
{
   perror("stat()");
   exit(1);
}

//非目录
if(!S_ISDIR(statres.st_mode))
   return statres.st_blocks;

//目录文件：递归处理
//拼接路径
strncpy(nextpath, path, PATHSIZE);
strncat(nextpath, "/*", PATHSIZE-1);
glob(nextpath, 0, NULL, &globres);
/*if(err)
{
   fprintf(stderr, "glob():errcode = %d\n", err);
   exit(1);
}*/

strncpy(nextpath, path, PATHSIZE);
strncat(nextpath, "/.*", PATHSIZE-1);
glob(nextpath, GLOB_APPEND, NULL, &globres); //追加方式
/*if(err)
{
   fprintf(stderr, "glob():errcode = %d\n", err);
   exit(1);
}
*/

sum = statres.st_blocks; //算上目录文件本身的大小
//目录下所有文件的大小
for(i=0; i<globres.gl_pathc; i++)
{
   if(path_noloop(globres.gl_pathv))
         sum += mydu(globres.gl_pathv);
}

globfree(&globres); //释放空间
return sum;

}

int main(int argc, char **argv)
{
if(argc < 2)
{
   fprintf(stderr, "Usage:...\n");
   exit(1);
}

printf("%ld\t%s\n",mydu(argv)/2, argv);

exit(0);
}运行结果：

2. 组信息： /etc/group

两个函数，用法同上
struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid)3. 加密： /etc/shadow

##include<stdlib.h>
##include<stdio.h>
##include<sys/types.h>
##include<pwd.h>

int main(int argc, char **argv)
{
   struct passwd *pwdline;

   if(argc < 2)
   {
            fprintf(stderr, "Usage:...\n");
            exit(1);
   }

   pwdline = getpwuid(atoi(argv));

   puts(pwdline->pw_name);

   exit(1);
}

makefile：crypt链接
例子：写一个 check-pass，用户输入用户名和密码，判断是否正确
思路：

[*]用户输入用户名，用户名通过 getnam 拿到 shadowline 的一行
[*]用户输入密码，密码通过 crypt 拿到用户输入密码加密后的密文
[*]将 shadowline 中的密文和用户输入密码加密后的密文比较，相等则成功，否则失败
示例代码：
struct group *getgrnam(const char *name);
struct group *getgrgid(gid_t gid);运行结果：

注意点：不知为何修改 makefile 没有作用，所以手动加上了；要用root执行，否则没有权限访问 /etc/shadow，会报段错误
4. 时间函数

围绕三种数据类型：

[*]time_t ：大整数，计算机喜欢
[*]struct tm ：结构体，程序员喜欢
[*]char * ：字符串，用户喜欢

涉及到的函数：
##include <shadow.h>
struct spwd *getspnam(const char *name);
//通过用户名得到 shadow文件中的一行

##include <crypt.h>
**链接的时候加这句：-lcrypt**
char *crypt(const char *phrase, const char *setting);
//将phrase和杂质串setting加密，返回加密后的串

##include <unistd.h>
char *getpass(const char *prompt);
//关闭终端回显功能，输入内容，再打开回显，返回输入的内容
//prompt是提示信息

[*]gmtime | localtime ：结果指针在静态区，所以结果要马上用，否则会被冲掉
[*]结构体成员

例子：编写 timelog.c 输出行号，时间戳，追加输入
示例代码：
##include<crypt.h>
##include<unistd.h>
##include<string.h>

int main(int argc, char **argv)
{
   char *input_pass;
   struct spwd *shadowline;
   char *crypted_pass;

   if(argc < 2)
   {
            fprintf(stderr, "Usage:...\n");
            exit(1);
   }

   input_pass = getpass("Password:");

   shadowline = getspnam(argv);

   crypted_pass = crypt(input_pass, shadowline->sp_pwdp);

   if(strcmp(crypted_pass, shadowline->sp_pwdp) == 0)
            puts("ok");
   else puts("fail");

   exit(0);
}运行结果：

注意点：

[*]进程被杀死后没有关闭文件：可控的内存泄漏，之后用钩子函数
[*]处理中断，都是全缓冲，要 fflush 否则看不到输出
例子： 100days.c ：查看100天后的日期
示例代码：
##include <time.h>
//拿到大整数
time_t time(time_t *tloc)

//大整数转结构体
struct tm *gmtime(const time_t *timep); //格林威治时间
struct tm *localtime(const time_t *timep); //本地时间

//结构体转字符串
size_t strftime(char *s, size_t max, const char *format,
                  const struct tm *tm);

//结构体转大整数：参数没有const修饰，会调整tm为合法
time_t mktime(struct tm *tm);运行结果：

三、进程环境

1. main函数

程序的入口与出口，一个程序有且仅有一个
2. 进程的终止

背过： Very Important!

exit、_exit、_Exit

[*]三者的返回值都是给父进程看。shell运行程序后可用 echo $? 查看
实际返回的状态数不是 int ：保留低八位，有符号 char -128 ~ +127

[*]exit 是库函数，其他是系统调用。
exit ：先清理现场，调用钩子函数等，后利用 _exit 退出
_exit ：直接退出

exit手册说明

[*]何时用 _exit ：遇到重大故障，防止故障扩散。

钩子函数

执行 exit 之前被逆序调用，像被钩上来一样。作用类似于析构函数。
##include<stdio.h>
##include<stdlib.h>
##include<time.h>
##include<unistd.h>

##define FNAME "/tmp/out"

int main()
{
FILE *fp;
int cnt=0;
size_t linesize;
char *timestr;
time_t stamp;
struct tm *tm;

fp = fopen(FNAME, "a+");
if(fp == NULL)
{
   perror("fopen()");
   exit(1);
}

timestr = NULL;
linesize = 0;
while(getline(&timestr, &linesize, fp) > 0)
cnt++;

while(1)
{
   time(&stamp);
   tm = localtime(&stamp);
   fprintf(fp, "%-4d: %d-%d-%d %d:%d:%d\n", ++cnt,
            tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
            tm->tm_hour, tm->tm_min, tm->tm_sec);
   fflush(fp);
   sleep(1);
}
fclose(fp);

exit(0);
}例子：演示钩子函数调用时机和顺序
示例代码：
##include<stdio.h>
##include<stdlib.h>
##include<time.h>

##define TIMESTRSIZE 1024

int main()
{
char timestr;
time_t stamp;
struct tm *tm;

time(&stamp);
tm = localtime(&stamp);
//各种格式参数查手册
strftime(timestr, TIMESTRSIZE, "Now: %Y-%m-%d", tm);
puts(timestr);

tm->tm_mday += 100;
mktime(tm);//利用mktime副作用修正tm
strftime(timestr, TIMESTRSIZE, "After 100 days: %Y-%m-%d", tm);
puts(timestr);

exit(0);
}运行结果：

具体的例子：释放打开的文件或其他需要逆操作的资源
不写钩子函数，代码体量会越来越大

钩子函数即可解决此问题，打开某一个文件后，立刻调用钩子函数。这样在进程正常结束前，就会调用钩子函数释放资源：

3. 命令行参数分析

int atexit(void (*function)(void));

[*]参数

[*]argc argv 就是命令行参数
[*]optstring 识别的选项

[*]前面加 - ：表示处理非选项，如 ls -a /tmp/out 中的 /tmp/out
[*]选项后加 : ：表示该选项有参数

[*]返回值

[*]读取完： -1
[*]成功：为选项→选项字符；非选项→1

[*]关联的全局变量

[*]optarg ：如果选项有参数，指向该参数
[*]optind ：index，当前在解析第几个参数，用的时候减1表示当前参数

getopt_long()：分析长格式如 ls --all
例子：mydate.c
示例代码：
##include<stdio.h>
##include<stdlib.h>

void f1(void)
{
puts("f1 is working");
}
void f2(void)
{
puts("f2 is working");
}
void f3(void)
{
puts("f3 is working");
}

int main()
{
puts("Begin");

atexit(f1);
atexit(f2);
atexit(f3);

puts("End");
exit(0);
}运行结果：

未实现的功能：解析非选项参数：指定日期的输出位置。如 ./mydate -y 4 /tmp/out 表示把年份输入到 /tmp/out 文件中
【视频42】
4. 环境变量

本质：Key = Value
##include <unistd.h>

int getopt(int argc, char * const argv[],
         const char *optstring);
//关联的全局变量
extern char *optarg;
extern int optind, opterr, optopt;

[*]getenv() ：提供键，返回值。例子： puts(getenv("PATH"))
[*]setenv() ：添加或修改键值对

[*]overwrite==1 ：键已存在，覆盖写
[*]overwrite==0 ：键已存在，不覆盖写

[*]putenv() ：添加或修改键值对，不推荐使用，因为参数没有const修饰，可能会被改变
注意：覆盖写的时候是情况原来的空间，然后转移到堆存储新的键值对。如果不这么做，如果修改后的值所占空间比原来的大，就无法存储。
其他：
export ：命令，查看环境变量
environ ：全局变量数组，类似于argv

5. C程序的存储空间和库

存储空间分布：从下到上：代码段、为初始化的数据段、初始化的数据段、堆、其他、栈、argc\argv。堆和栈的空间可以变动。
3G以上是内核信息

命令 pmap ：查看一个程序的空间：
编一个程序，getchar等待输入，然后另开一个终端 ps axf 查看进程号，然后执行 pmap

库：

手册example。注意使用上述函数的时候要 Link with -ldl.

6. setjmp\longjmp

[*]类 goto 函数的必要性
查找有1000层的数的某个结点，没有改变函数空间，那么可以goto快速返回；C++异常抛出机制
经过复杂步骤进来，且没有改变空间，就可以goto快速返回

goto不能实现跨函数跳转，因为现场没有切换。
setjmp 和 longjmp 解决了这个问题。安全地跨函数跳转，被称为长返回，长跳转。
##include<stdio.h>
##include<stdlib.h>
##include<time.h>
##include<unistd.h>
##include<string.h>

##define TIMESTRSIZE 1024
##define STROPTSIZE1024

int main(int argc, char **argv)
{
char timestr;
char stropt;
time_t stamp;
struct tm *tm;
int c;
FILE *fp = stdout;

time(&stamp);
tm = localtime(&stamp);

//先初始化为空串，再往里追加
stropt = '\0';
while(1)
{
   c = getopt(argc, argv, "-H:MSy:md");
   if(c < 0) break;
   switch(c)
   {
         /*case 1:
            fp = fopen(argv, "w");
            if(fp == NULL)
            {
                  perror("fopen()");
                  //文件打开失败则写往终端
                  fp = stdout;
            }
            break;*/
         case 'H':
            if(strcmp("12", optarg) == 0)
               strncat(stropt, "%I(%P) ", STROPTSIZE-1);
            else if(strcmp("24", optarg) == 0)
               strncat(stropt,"%H ", STROPTSIZE-1);
            else
               fprintf(stderr, "Invalid argument of -H\n");
            break;
         case 'M':
            strncat(stropt,"%M ", STROPTSIZE-1);
            break;
         case 'S':
            strncat(stropt,"%S ", STROPTSIZE-1);
            break;
         case 'y':
            if(strcmp("2", optarg) == 0)
               strncat(stropt,"%y ", STROPTSIZE-1);
            else if(strcmp("4", optarg) == 0)
                  strncat(stropt,"%Y ", STROPTSIZE-1);
            else
               fprintf(stderr, "Invalid argument of -y\n");
            break;
         case 'm':
            strncat(stropt,"%m ", STROPTSIZE-1);
            break;
         case 'd':
            strncat(stropt,"%d ", STROPTSIZE-1);
            break;
         default:
            break;
   }
}

strncat(stropt, "\n", TIMESTRSIZE-1);
strftime(timestr, TIMESTRSIZE, stropt, tm);
fputs(timestr, fp);

//非标准输出才关闭，否则会关闭标准输出
if(fp != stdout)
   fclose(fp);
exit(0);
}

[*]setjmp 返回值类似fork，后面加分支：如果顺次执行，返回0，跳转回来则返回携带的值。
[*]longjmp 第二个参数带回0，会被替换为1，防止死循环
例子：跨函数跳转
示例代码：
char *getenv(const char *name);

int setenv(const char *name, const char *value, int overwrite);
int putenv(char *string);运行结果：

没跳转

跳转【运行结果】
7. 资源获取及控制

命令 ulimit 用下面两个函数实现：

[*]软限制小于等于硬限制
[*]普通用户不能提高硬限制， root可以

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

娥搽裙 发表于 2025-10-19 00:41:25

鼓励转贴优秀软件安全工具和文档！

纣捎牟 发表于 2025-10-31 04:40:03

很好很强大我过来先占个楼待编辑

骆贵发表于 2025-11-1 20:30:16

前排留名，哈哈哈

兼罔发表于 3 天前

用心讨论，共获提升！

少屠发表于前天 07:11

东西不错很实用谢谢分享

页: [1]

程序园's Archiver

linux系统编程01-文件系统