第39讲：一切皆文件

// 无论是普通文件、设备、还是进程信息
// 用户都可以用同样的 open/read/write 接口操作
fd = open("/dev/ttyUSB0", O_RDWR);  // 串口设备
write(fd, "hello", 5);
read(fd, buf, 10);
close(fd);

# 1. 查看普通文件（常规操作）
ls -l /etc/passwd
cat /etc/passwd

# 2. 查看设备文件 —— 磁盘也是一个"文件"
ls -l /dev/sda
# 输出类似: brw-rw---- 1 root disk 8, 0 Jul 21 10:00 /dev/sda

# 3. 终端本身也是一个"文件" —— 当前你正在使用的终端
tty
# 输出类似: /dev/pts/0

# 4. 往终端"文件"里写数据，等同于在屏幕上打印
echo "Hello from file write!" > /dev/pts/0

# 5. 零设备 —— 一个永远返回0的特殊文件
dd if=/dev/zero of=test.bin bs=1024 count=10
# 生成了一个全是0的10KB文件

# 6. 空设备 —— 一个吞噬一切数据的"黑洞"
echo "这条数据被丢弃了" > /dev/null

# 7. 随机数设备 —— 读取它得到随机字节
head -c 16 /dev/urandom | od -A x -t x1z

用户应用
    ↓
C库函数 (fopen/fread/fwrite)
    ↓
系统调用 (open/read/write)
    ↓
┌──────────────────────────────────┐
│      VFS 抽象层                   │
│  (屏蔽底层差异，提供统一接口)       │
└──────────────────────────────────┘
    ↓
ext4  FAT32  yaffs  procfs  sysfs

# ===== /proc —— 进程和内核信息的"文件"视图 =====

# 查看 CPU 信息 —— CPU 的型号、频率、核心数都在这
cat /proc/cpuinfo | head -20

# 查看内存信息 —— 总内存、可用内存、缓冲区等
cat /proc/meminfo | head -10

# 查看内核版本
cat /proc/version

# 查看系统运行时间（开机了多久）
cat /proc/uptime

# 查看当前进程列表 —— 每个数字目录就是一个 PID
ls /proc | head -20

# 查看某个进程的命令行（假设 PID=1，即 systemd/init 进程）
cat /proc/1/cmdline
echo ""
cat /proc/1/status | head -10

# 查看当前 Shell 自己的进程信息
cat /proc/$$/status | head -10
# $$ 是当前 Shell 的 PID


# ===== /sys —— 硬件设备和内核模块的"文件"视图 =====

# 查看系统中有哪些块设备（磁盘、U盘等）
ls /sys/block/

# 查看第一个硬盘的大小（单位：扇区，每扇区通常512字节）
cat /sys/block/sda/size

# 查看 CPU 的拓扑结构
ls /sys/devices/system/cpu/

# 查看某个 CPU 核心是否在线
cat /sys/devices/system/cpu/cpu0/online


# ===== /dev —— 设备节点的"文件"视图 =====

# 查看所有设备文件
ls -l /dev/ | head -30

# 注意第一列的第一个字符：
#   b = 块设备(block device)，如硬盘 sda
#   c = 字符设备(character device)，如终端 tty、串口 ttyUSB0

# 查看磁盘分区
ls -l /dev/sd*

# 查看终端设备
ls -l /dev/tty*

# 用 file 命令查看设备文件的类型
file /dev/sda
file /dev/tty
file /dev/null
file /dev/zero
file /dev/urandom

# 查看当前有哪些文件系统被挂载了
mount | head -20

# 更详细的信息（包含文件系统类型）
df -T

# 输出示例：
# Filesystem     Type     1K-blocks    Used Available Use% Mounted on
# /dev/sda1      ext4      51474912 8234108  40585400  17% /
# tmpfs          tmpfs      1638060       0   1638060   0% /dev/shm

# 查看 /proc/mounts —— 内核视角的挂载信息
cat /proc/mounts | head -20

# 创建一个测试文件
echo "hello inode" > test_inode.txt

# 查看文件的 inode 编号（-i 参数）
ls -i test_inode.txt
# 输出示例: 1234567 test_inode.txt

# 更详细地查看 inode 信息（stat 命令）
stat test_inode.txt

# stat 输出示例：
#   File: test_inode.txt
#   Size: 12              Blocks: 8          IO Block: 4096   regular file
# Device: 801h/2049d      Inode: 1234567     Links: 1
# Access: (0644/-rw-r--r--)  Uid: (1000/ user)   Gid: (1000/ user)
# Access: 2026-07-22 10:00:00.000000000 +0800
# Modify: 2026-07-22 10:00:00.000000000 +0800
# Change: 2026-07-22 10:00:00.000000000 +0800

# 创建硬链接 —— 两个文件名指向同一个 inode
ln test_inode.txt test_inode_link.txt
ls -i test_inode.txt test_inode_link.txt
# 两个文件的 inode 编号完全一样！说明它们本质是同一个文件

# 删除原文件，硬链接仍然可以访问
rm test_inode.txt
cat test_inode_link.txt
# 输出: hello inode

# 清理
rm test_inode_link.txt

# 查看当前 Shell 打开的文件描述符
ls -l /proc/$$/fd/

# 输出类似：
# lrwx------ 1 user user 64 Jul 22 10:00 0 -> /dev/pts/0  (标准输入)
# lrwx------ 1 user user 64 Jul 22 10:00 1 -> /dev/pts/0  (标准输出)
# lrwx------ 1 user user 64 Jul 22 10:00 2 -> /dev/pts/0  (标准错误)

# 查看某个进程（如PID=1的systemd）打开了哪些文件
sudo ls -l /proc/1/fd/ 2>/dev/null | head -20

# 用 lsof 查看某个进程打开的所有文件
lsof -p $$ 2>/dev/null | head -20

struct inode_operations {
    int (*create)(struct inode *dir, struct dentry *dentry, ...);  // 创建文件
    int (*mkdir)(struct inode *dir, struct dentry *dentry, ...);   // 创建目录
    int (*rename)(struct inode *old_dir, struct dentry *old_dentry, ...);  // 重命名
    int (*link)(struct dentry *old_dentry, struct inode *dir, ...);  // 硬链接
    int (*unlink)(struct inode *dir, struct dentry *dentry);       // 删除文件
    // ...
};

# 创建文件 → 内核调用 inode_operations->create
touch new_file.txt

# 创建目录 → 内核调用 inode_operations->mkdir
mkdir test_dir

# 创建硬链接 → 内核调用 inode_operations->link
ln new_file.txt hardlink_to_file.txt
ls -i new_file.txt hardlink_to_file.txt

# 重命名 → 内核调用 inode_operations->rename
mv new_file.txt renamed_file.txt

# 删除文件 → 内核调用 inode_operations->unlink
rm renamed_file.txt hardlink_to_file.txt

# 删除目录
rmdir test_dir

struct file_operations {
    int (*open)(struct inode *inode, struct file *file);     // 打开文件
    ssize_t (*read)(struct file *file, char *buf, ...);      // 读文件
    ssize_t (*write)(struct file *file, const char *buf, ...); // 写文件
    int (*release)(struct inode *inode, struct file *file);  // 关闭文件
    // ...
};

# 创建一个简单的测试文件
echo "hello VFS" > test_vfs.txt

# 用 strace 追踪 cat 命令的系统调用
strace cat test_vfs.txt 2>&1 | grep -E "open|read|write|close"

# 典型输出（简化）：
# openat(AT_FDCWD, "test_vfs.txt", O_RDONLY) = 3
# read(3, "hello VFS\n", 131072)           = 10
# write(1, "hello VFS\n", 10)              = 10
# close(3)                                 = 0

# 可以看到：cat 命令最终调用了 open → read → write → close
# 这就是 file_operations 在用户态的"影子"

# 清理
rm test_vfs.txt

VFS 定义的操作接口（框架）
    ↑         ↑         ↑
    |         |         |
ext4填充   FAT32填充   sysfs填充
 自己的操作   自己的操作    自己的操作

# ext4 的 read：从磁盘扇区读取数据
# procfs 的 read：从内核内存动态生成数据（根本没有磁盘！）

# 演示：/proc/cpuinfo 不是一个真实文件
ls -l /proc/cpuinfo
# 会显示大小为 0，因为数据是实时生成的

# 但你可以正常"读取"它
cat /proc/cpuinfo | head -5
# 有内容！因为 proc_read 在内核中动态构造了这些数据

# 对比普通文件
ls -l /etc/hostname
cat /etc/hostname

# 两者都用了同样的命令（ls、cat），但底层走的是完全不同的路径

应用层（用户程序）
    ↓ 调用 C 库函数 (fopen/fread/fwrite)
C库函数（glibc）
    ↓ 调用 系统调用
系统调用层 (sys_open/sys_read/sys_write)
    ↓ 调用 VFS 抽象接口
VFS 抽象层
    ↓ 调用 具体文件系统的填充函数
具体文件系统 (ext4/FAT32/procfs/sysfs)
    ↓
硬件设备

# 准备测试文件
echo "Linux VFS demo" > /tmp/vfs_demo.txt

# 完整追踪 cat 命令（输出到文件以便查看）
strace -o /tmp/strace_output.txt cat /tmp/vfs_demo.txt

# 查看追踪结果中的关键系统调用
grep -E "openat|read|write|close" /tmp/strace_output.txt

# 更详细的追踪（显示每个系统调用的时间消耗）
strace -T cat /tmp/vfs_demo.txt 2>&1 | grep -E "openat|read|write|close"

# 典型输出：
# openat(AT_FDCWD, "/tmp/vfs_demo.txt", O_RDONLY) = 3 <0.000021>
# read(3, "Linux VFS demo\n", 131072) = 15 <0.000015>
# write(1, "Linux VFS demo\n", 15) = 15 <0.000017>
# close(3)                                = 0 <0.000007>

# 这个调用过程就是：
# 用户调用 cat → glibc 翻译为 openat() → 系统调用 sys_openat()
# → VFS → ext4 具体文件系统的 ext4_file_open() → 硬盘驱动 → 硬盘

# 清理
rm /tmp/vfs_demo.txt /tmp/strace_output.txt

# 查看当前进程的文件描述符
ls -l /proc/$$/fd/

# 文件描述符 0/1/2 都是指向同一个终端设备文件
# 这说明：键盘是文件，屏幕也是文件

# 证明：直接往文件描述符写数据
echo "写入 stdout" >&1     # 等价于 echo 写入显示器
echo "写入 stderr" >&2     # 等价于错误输出

# 把标准错误重定向到文件
ls /nonexistent_dir 2>/tmp/error.log
cat /tmp/error.log
rm /tmp/error.log

# 零设备 —— 产生无限的零字节
dd if=/dev/zero of=/tmp/empty.bin bs=1M count=10
ls -lh /tmp/empty.bin
# 生成了一个 10MB 的全零文件

# 随机数设备 —— 产生无限的随机数据
dd if=/dev/urandom of=/tmp/random.bin bs=1K count=1
hexdump -C /tmp/random.bin | head -5

# 空设备 —— 测试用的"黑洞"
# 扔掉所有输出（常用于禁止命令的屏幕输出）
find / -name "*.log" > /dev/null 2>&1

# 内存设备 —— 把内存当磁盘用
# /dev/shm 是一个挂在内存中的文件系统（tmpfs），速度极快
df -h /dev/shm
echo "fast storage" > /dev/shm/test.txt
cat /dev/shm/test.txt
rm /dev/shm/test.txt

# 清除
rm /tmp/empty.bin /tmp/random.bin 2>/dev/null

# === 查看系统信息（都是"读文件"操作）===

# CPU 型号和核心数量
echo "CPU 型号:"
grep "model name" /proc/cpuinfo | head -1
echo "CPU 核心数:"
grep -c "processor" /proc/cpuinfo

# 内存使用情况
echo "总内存:"
grep "MemTotal" /proc/meminfo
echo "可用内存:"
grep "MemAvailable" /proc/meminfo

# 系统负载
cat /proc/loadavg

# 内核启动参数（boot 时传递的参数）
cat /proc/cmdline


# === 查看进程信息 ===

# 列出所有进程（数字目录名就是 PID）
ls /proc | grep -E '^[0-9]+$' | head -20

# 查看 PID=1 的进程详情（通常是 systemd 或 init）
echo "进程名: $(cat /proc/1/comm)"
echo "进程状态:"
head -3 /proc/1/status

# 查看当前 Shell 进程的环境变量
cat /proc/$$/environ | tr '\0' '\n' | head -10

# 查看进程的内存映射（虚拟地址空间布局）
head -20 /proc/$$/maps

# === 查看硬件设备树 ===

# 系统中有哪些块设备
ls /sys/block/

# 查看第一个磁盘的容量（扇区数）
if [ -f /sys/block/sda/size ]; then
    SIZE=$(cat /sys/block/sda/size)
    echo "磁盘扇区数: $SIZE"
    echo "磁盘容量: $(($SIZE * 512 / 1024 / 1024 / 1024)) GB（假设扇区=512B）"
fi

# 查看 CPU 信息
ls /sys/devices/system/cpu/
cat /sys/devices/system/cpu/possible  # 可能的 CPU 编号
cat /sys/devices/system/cpu/present   # 当前存在的 CPU

# 查看网卡信息
ls /sys/class/net/
# 输出类似: eth0 lo wlan0

# 查看某个网卡的 MAC 地址
if [ -f /sys/class/net/eth0/address ]; then
    cat /sys/class/net/eth0/address
fi

# === 修改内核参数（通过写文件改变系统行为）===

# 开启 IP 转发（让 Linux 变成路由器）
# 注意：这个操作需要 root 权限，仅作演示
# echo 1 > /proc/sys/net/ipv4/ip_forward

# 查看当前是否开启了 IP 转发
cat /proc/sys/net/ipv4/ip_forward
# 输出 0 = 未开启，1 = 已开启

# 管道的本质：一个内核缓冲区，可以被当作文件读写

# 匿名管道 —— 最常用的 |
ls -l / | grep "^d" | wc -l
# ls 的输出通过管道传给 grep，grep 的输出通过管道传给 wc

# 命名管道（FIFO）—— 一个有名字的"管道文件"
mkfifo /tmp/my_pipe
ls -l /tmp/my_pipe
# 注意文件类型：p（p = pipe）
# prw-r--r-- 1 user user 0 Jul 22 10:00 /tmp/my_pipe

# 终端1：往管道写数据（会阻塞，直到有人读取）
# echo "Hello via pipe" > /tmp/my_pipe

# 终端2：从管道读数据
# cat /tmp/my_pipe

# 清理
rm /tmp/my_pipe

# 错误示范：试图"删除" /proc/cpuinfo
# rm /proc/cpuinfo
# 结果：rm: cannot remove '/proc/cpuinfo': Operation not permitted

# 正确示例：读取硬件温度（如果系统支持）
cat /sys/class/thermal/thermal_zone0/temp 2>/dev/null

# 可写的例子（需 root 权限，仅作概念演示）：
# echo "performance" > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
# 这行命令改变了 CPU 调频策略 —— 通过"写文件"来配置内核！

# 同一个进程可以打开同一个文件两次
# 它们有不同的文件描述符，但有各自的偏移量

exec 3<> /tmp/fd_demo.txt   # 以读写方式打开，分配 fd=3
echo "line 1" >&3

exec 4<> /tmp/fd_demo.txt   # 再次打开同一个文件，分配 fd=4
echo "line 2" >&4

# 查看文件内容
cat /tmp/fd_demo.txt

# 关闭文件描述符
exec 3>&-
exec 4>&-
rm /tmp/fd_demo.txt

┌─────────────────────────────────────┐
│          用户应用                    │
│  (fopen/fread/fwrite)              │
├─────────────────────────────────────┤
│          C 库函数 (glibc)           │
├─────────────────────────────────────┤
│          系统调用                    │
│  (sys_open/sys_read/sys_write)     │
├─────────────────────────────────────┤
│  ┌───────────────────────────────┐  │
│  │        VFS 抽象层             │  │
│  │  ┌──────────┐ ┌──────────┐   │  │
│  │  │inode_ops │ │file_ops  │   │  │
│  │  │┌──────┐│ │┌──────┐│   │  │
│  │  ││create ││ ││open  ││   │  │
│  │  ││mkdir  ││ ││read  ││   │  │
│  │  ││unlink ││ ││write ││   │  │
│  │  ││rename ││ ││release││   │  │
│  │  │└──────┘│ │└──────┘│   │  │
│  │  └──────────┘ └──────────┘   │  │
│  └───────────────────────────────┘  │
├─────────┬──────┬──────┬─────────────┤
│  ext4   │ FAT32│procfs│   sysfs     │
└─────────┴──────┴──────┴─────────────┘