ls / --group-directories-first
# bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run
# sbin  srv  sys  tmp  usr  var

# ① /usr 是【静态可共享】 -> 可以只读挂载，也可以多机共享一份
mount -o remount,ro /usr
#                   ^^ 只读挂载 /usr 是嵌入式设备和高安全环境的常规做法：
#                      系统程序不可能被篡改，因为分区本身就是只读的
# 容器镜像的分层设计也是同一个思路：/usr 那层是只读的镜像层

# ② /etc 是【静态不可共享】 -> 每台机器的配置不同，但装完基本不变
#    所以 /etc 应该进版本控制（etckeeper），也应该重点备份

# ③ /var 是【可变不可共享】 -> 唯一会持续增长的地方
#    所以生产机的标准做法是给 /var 单独分区，防止日志打满根分区导致系统不可用
df -h /var
# /dev/vdb1  100G  12G  88G  12% /var
#  ^^^^^^^^ 独立分区。就算日志写爆了，/ 还有空间让你 ssh 进来处理

# ④ /home 是【可变可共享】 -> 所以企业里常用 NFS 挂载家目录，
#    用户在任意一台机器登录都能看到自己的文件

ls -ld /bin /sbin /lib /lib64
# lrwxrwxrwx 1 root root 7 Apr 22  2023 /bin -> usr/bin
# lrwxrwxrwx 1 root root 8 Apr 22  2023 /sbin -> usr/sbin
# lrwxrwxrwx 1 root root 7 Apr 22  2023 /lib -> usr/lib
# lrwxrwxrwx 1 root root 9 Apr 22  2023 /lib64 -> usr/lib64
#                                        ^^^^^^^^^^^^^^^^ 全是软链接

# 所以这两条命令跑的是【同一个文件】
ls -i /bin/ls /usr/bin/ls
# 2097347 /bin/ls    2097347 /usr/bin/ls     <- inode 号相同

#!/bin/bash              # 大多数 Linux 通用（/bin 一定存在）
#!/usr/bin/bash          # 在没做 usrmerge 的老系统上可能不存在
#!/usr/bin/env bash      # ✅ 最可移植：去 PATH 里找 bash
#                           macOS 上 bash 在 /opt/homebrew/bin，这种写法才能兼容

# 场景一：手动装 Go（官方 tarball 建议解压到 /usr/local）
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
#                 ^^^^^^^^^^^^^^^^^ Go 是"自带目录结构"的，所以放 /usr/local/go 整个目录

# 场景二：编译安装某个工具（GNU 三部曲）
./configure --prefix=/usr/local     # 默认就是它，会装到 /usr/local/{bin,lib,share,include}
make && sudo make install
# 卸载困难是这种方式的最大问题（没有清单），所以更推荐 checkinstall 或直接用包管理器

# 场景三：下载的单个二进制
sudo install -m 755 kubectl /usr/local/bin/kubectl
#    ^^^^^^^ 用 install 而不是 cp：一步完成复制 + 权限（见 04 篇 10.14）

# 场景四：自己写的 Go 工具，只给自己用
go install github.com/x/tool@latest       # 装到 $(go env GOPATH)/bin，即 ~/go/bin
export PATH=$PATH:$(go env GOPATH)/bin

/etc/
├── passwd, shadow, group          # 用户与组（第 10 篇）
├── hosts, resolv.conf, hostname   # 网络基础（第 15 篇）
├── fstab                          # 开机挂载表（第 11 篇）
├── crontab, cron.d/               # 定时任务（第 14 篇）
├── sudoers, sudoers.d/            # 提权规则（第 10 篇）
├── ssh/sshd_config                # SSH 服务端配置（第 16 篇）
├── systemd/system/                # systemd 单元文件（第 14 篇）
├── nginx/, mysql/                 # 各软件自己的配置目录
├── profile, profile.d/, bash.bashrc   # 全局 shell 配置
├── default/  (Debian 系)          # 服务的环境变量与启动参数
└── sysconfig/  (RHEL 系)          # 同上，RHEL 的叫法

grep -r 'include' /etc/nginx/nginx.conf
# include /etc/nginx/conf.d/*.conf;
# include /etc/nginx/sites-enabled/*;

# 为什么这么设计？因为它让【自动化】变得安全：
# 加一个站点 = 往目录里丢一个文件（幂等、可回滚、不用改主文件）
# 而不是用 sed 去主配置文件里插一段（容易改坏、无法回滚、并发写会冲突）

# 所以你的部署脚本应该这样做
sudo tee /etc/nginx/conf.d/myapp.conf > /dev/null <<'EOF'
server { listen 8080; location / { proxy_pass http://127.0.0.1:3000; } }
EOF
sudo nginx -t && sudo systemctl reload nginx
#         ^^ 永远先测试语法再 reload

cat /etc/default/grub          # GRUB 的配置在这，改完要 update-grub

sudo apt install etckeeper     # 自动把 /etc 变成 git 仓库，每次 apt 操作自动提交
cd /etc && sudo git log --oneline | head
# 谁在什么时候改了什么配置，一目了然

/var/
├── log/          # 日志 ← 磁盘爆满的头号元凶
├── lib/          # 程序的持久化数据（/var/lib/mysql、/var/lib/docker）
├── cache/        # 缓存，删了不影响正确性（只是变慢）
├── spool/        # 队列：待发邮件、打印任务、cron 任务
├── tmp/          # 临时文件，【跨重启保留】
├── run  -> /run  # 软链接，见下
└── www/          # 网站文件（有些发行版放这）

sudo du -xh --max-depth=1 /var | sort -h | tail
# 12G    /var/lib          <- 数据，慎动
# 8.2G   /var/log          <- 日志，可清
# 3.1G   /var/cache        <- 缓存，随便清

sudo apt clean                       # 清 /var/cache/apt/archives 里的 deb 包
sudo journalctl --vacuum-size=500M   # 把 journal 日志压到 500MB 以内
sudo docker system prune -a          # 清未使用的镜像（/var/lib/docker 常是最大头）

findmnt /run
# TARGET SOURCE FSTYPE OPTIONS
# /run   tmpfs  tmpfs  rw,nosuid,nodev,noexec,relatime,size=1608468k,mode=755
#               ^^^^^ 内存文件系统，不落盘

ls /run
# containerd/  docker.sock  lock/  nginx.pid  sshd.pid  systemd/  user/  utmp

ls -ld /var/run
# lrwxrwxrwx 1 root root 4 Aug 12 22:00 /var/run -> /run     <- 历史兼容软链接

# 你的 Go 服务如果要写 pid 或 unix socket，正确位置是
/run/myapp/myapp.pid
/run/myapp/myapp.sock

# 目录需要提前创建，systemd 提供了声明式的方式（不用自己 mkdir）
# /etc/systemd/system/myapp.service
# [Service]
# RuntimeDirectory=myapp            <- systemd 自动创建 /run/myapp，停止时自动删除
# RuntimeDirectoryMode=0750

findmnt /tmp
# /tmp tmpfs tmpfs rw,nosuid,nodev,size=8065536k       <- 是 tmpfs，写它等于写内存

ls -ld /tmp
# drwxrwxrwt 20 root root 4096 Aug 12 22:00 /tmp
#          ^ 这个 t 是 Sticky 位：人人可写，但【只能删自己的文件】
#            没有它，任何人都能删别人的临时文件（第 10 篇讲）

# ① /tmp 是 tmpfs 时，往它写大文件 = 吃内存，可能触发 OOM
dd if=/dev/zero of=/tmp/big bs=1M count=10000      # 💀 直接吃掉 10GB 内存
# 大文件应该写 /var/tmp 或专门的数据目录

# ② systemd 服务默认可能启用 PrivateTmp，此时服务看到的 /tmp 不是你看到的 /tmp
systemctl show nginx -p PrivateTmp
# PrivateTmp=yes
# -> nginx 的 /tmp 实际是 /tmp/systemd-private-xxx-nginx.service-yyy/tmp
# 这解释了"程序说文件写在 /tmp 但我找不到"的困惑
sudo ls /tmp/systemd-private-*/tmp/

df -h /proc /sys
# Filesystem  Size  Used Avail Use% Mounted on
# proc           0     0     0    - /proc            <- 大小是 0
# sysfs          0     0     0    - /sys

ls -l /proc/meminfo
# -r--r--r-- 1 root root 0 Aug 12 22:00 /proc/meminfo
#                        ^ 大小显示 0，但 cat 出来有几十行 —— 内容是读时才生成的

# 系统级
cat /proc/cpuinfo          # CPU 详情
cat /proc/meminfo          # 内存详情（free 命令的数据来源）
cat /proc/loadavg          # 平均负载（uptime 的数据来源）
cat /proc/version          # 内核版本
cat /proc/mounts           # 当前挂载表（比 /etc/mtab 可靠）
cat /proc/net/tcp          # TCP 连接表（ss 的数据来源之一）
ls /proc/sys/net/ipv4/     # 内核参数，可读可写（sysctl 操作的就是这里）

# 进程级：/proc/<pid>/ ← 排查问题的金矿
PID=1234
ls -l /proc/$PID/exe       # 程序的真实路径（即使被删了也能看到）
ls -l /proc/$PID/cwd       # 进程的当前工作目录
ls -l /proc/$PID/fd/       # 打开的所有 fd（查 fd 泄漏、查已删除文件）
cat /proc/$PID/cmdline | tr '\0' ' '    # 完整启动命令（参数用 \0 分隔）
cat /proc/$PID/environ | tr '\0' '\n'   # 环境变量（查"配置没生效"）
cat /proc/$PID/status      # 状态汇总：内存、线程数、uid、信号掩码
cat /proc/$PID/limits      # 资源限制（查 too many open files）
cat /proc/$PID/stack       # 内核栈（进程 D 状态卡死时看它卡在哪个内核函数）
wc -l < /proc/$PID/maps    # 内存映射区域数量

# 自己进程的快捷方式
ls -l /proc/self/cwd

cat /sys/fs/cgroup/cpu.max          # 容器的 CPU 限额（cgroup v2）
cat /sys/fs/cgroup/memory.max       # 内存限额
cat /sys/fs/cgroup/memory.current   # 当前用量
cat /sys/block/vda/queue/scheduler  # 磁盘 IO 调度器
cat /sys/class/net/eth0/mtu         # 网卡 MTU

# 容器里（限额 512MB）
free -h
#                total        used        free
# Mem:            62Gi        20Gi        30Gi        <- 宿主机的数据！

# 真实限额要读 cgroup
cat /sys/fs/cgroup/memory.max
# 536870912                                           <- 512MB，这才是真的

# 后果：JVM/Go 的自动内存调优会按 62GB 来算，然后被 OOMKilled
# 解法：Go 设 GOMEMLIMIT，或用 lxcfs 让 /proc 反映 cgroup 值

ls -l /dev/null /dev/zero /dev/urandom /dev/sda
# crw-rw-rw- 1 root root  1, 3 Aug 12 /dev/null      <- c = 字符设备
# crw-rw-rw- 1 root root  1, 5 Aug 12 /dev/zero
# crw-rw-rw- 1 root root  1, 9 Aug 12 /dev/urandom
# brw-rw---- 1 root disk  8, 0 Aug 12 /dev/sda       <- b = 块设备
#                         ^^^^ 主设备号,次设备号 —— 内核靠这两个数字找到驱动，
#                              而不是靠文件名（文件名只是给人看的）

cmd > /dev/null 2>&1        # 黑洞：丢弃所有输出
dd if=/dev/zero of=f bs=1M count=100    # 零源：产生无限个 \0
head -c 32 /dev/urandom | base64        # 随机数（生成密钥/密码）
# /dev/random vs /dev/urandom：现代内核（5.6+）两者行为已基本一致，
#   直接用 urandom 即可，别再迷信 random 更安全（它只是可能阻塞）

echo "hi" > /dev/tty        # 直接写到终端（绕过重定向，脚本里给用户提示用）
cat /dev/stdin              # 标准输入（等价 -）
ls -l /dev/std{in,out,err}  # 都是指向 /proc/self/fd/{0,1,2} 的软链接

ls -A ~ | head -20
# .bashrc  .bash_history  .profile  .vimrc  .gitconfig  .ssh  .cache
# .config  .local  .npm  .docker  .kube  .aws  .gnupg  .python_history  ...
ls -A ~ | wc -l         # 几十上百个，配置、缓存、数据全混在一起

ls ~/.config              # nvim/  git/  gh/  htop/  systemd/
ls ~/.local/share         # nvim/  fish/  containers/
du -sh ~/.cache           # 3.2G    <- 经常是家目录最大的部分，随时可删
rm -rf ~/.cache/*         # 安全操作（程序会自己重建）

echo $XDG_RUNTIME_DIR     # /run/user/1000
ls -ld /run/user/1000
# drwx------ 8 lhx lhx 240 Aug 12 22:00 /run/user/1000
#          ^^^^^^ 只有你自己能进，由 systemd-logind 在登录时创建、登出时销毁
# podman、pipewire、tmux 的 socket 都放这

// ✅ 用标准库，自动遵守 XDG（并在 macOS/Windows 上给出对应位置）
cfgDir, _ := os.UserConfigDir()    // Linux: ~/.config    macOS: ~/Library/Application Support
cacheDir, _ := os.UserCacheDir()   // Linux: ~/.cache     macOS: ~/Library/Caches
homeDir, _ := os.UserHomeDir()

configPath := filepath.Join(cfgDir, "myapp", "config.yaml")

// ❌ 不要硬编码
configPath := os.Getenv("HOME") + "/.myapp/config.yaml"   // 又往家目录扔垃圾了

sudo -u app systemctl --user status
# Failed to connect to bus: $DBUS_SESSION_BUS_ADDRESS and $XDG_RUNTIME_DIR not defined
# ✅ 解法：用 machinectl shell 或给该用户开启 linger
sudo loginctl enable-linger app     # 让该用户的 /run/user/<uid> 常驻，不随登出销毁

# /etc/systemd/system/myapp.service
[Unit]
Description=My Go Service
After=network-online.target

[Service]
Type=notify
User=myapp
Group=myapp
ExecStart=/usr/local/bin/myapp --config /etc/myapp/config.yaml
EnvironmentFile=-/etc/default/myapp

# systemd 自动创建这些目录并设好属主，服务停止时按需清理
RuntimeDirectory=myapp              # -> /run/myapp        （停止时删除）
StateDirectory=myapp                # -> /var/lib/myapp    （保留）
CacheDirectory=myapp                # -> /var/cache/myapp
LogsDirectory=myapp                 # -> /var/log/myapp
ConfigurationDirectory=myapp        # -> /etc/myapp

# 顺带一提，这几个加固选项建议默认开
ProtectSystem=strict                # /usr /boot /etc 只读（呼应 1.1 的"静态可共享"）
ProtectHome=yes                     # 看不到 /home
PrivateTmp=yes                      # 独立的 /tmp
NoNewPrivileges=yes                 # 禁止提权

[Install]
WantedBy=multi-user.target

/var/log/app.log        # 绝对路径：以 / 开头，从根目录开始
var/log/app.log         # 相对路径：从【当前工作目录】开始
./app.log               # 显式相对（. 表示当前目录）
../sibling/f            # 上一级
~/project/main.go       # ~ 由 shell 展开成 $HOME，【内核不认识 ~】
~root/.ssh              # 展开成 root 用户的家目录

# ✅ 能用：shell 展开了 ~
ls ~/data

# ❌ 不能用：引号阻止了展开，内核收到的是字面量 "~/data"
ls "~/data"
# ls: cannot access '~/data': No such file or directory

# ✅ 正确写法
ls "$HOME/data"
ls ~/"data with space"       # ~ 在引号外，路径其余部分在引号内

# ① 多个连续斜杠等价于一个
ls /var//log///app.log        # 与 /var/log/app.log 完全相同
# 例外：开头恰好两个斜杠（//）POSIX 允许实现自定义含义，Linux 上仍等价于 /

# ② 末尾斜杠 = 断言"这必须是个目录"
ls /etc/                      # 正常
ls /etc/passwd/               # ls: cannot access: Not a directory
# 实用价值：mv src dst/ 能确保 dst 是目录，避免把 src 重命名成 dst 文件

# ③ 长度限制
getconf PATH_MAX /            # 4096   整条路径的最大字节数
getconf NAME_MAX /            # 255    单个文件名的最大字节数（注意是字节，中文占 3 字节）
# 中文文件名最多 85 个字（255/3）
python3 -c "print(len('很长的中文名'.encode()))"

# ④ 路径里什么字符都行，除了 / 和 \0（见 04 篇第 8 节）

ls -ai /tmp | head -3
# 2621441 .          <- 指向自己
#       2 ..         <- 指向父目录（这里 /tmp 的父是 /，inode 号 2）
# 2621500 somefile

stat -c '%i' /tmp /tmp/. /tmp/..
# 2621441
# 2621441        <- . 和 /tmp 是同一个 inode
# 2               <- .. 就是 / 的 inode

stat -c '%i' / /.. /../..
# 2
# 2          <- 根目录的 .. 指向它自己（到顶了就不再往上）
# 2

namei -l /var/www/html/index.html
# f: /var/www/html/index.html
# dr-xr-xr-x root root /
# drwxr-xr-x root root var
# drwx------ root root www           <- 就是这一层！other 没有 x，任何非 root 都进不去
# drwxr-xr-x root root html
# -rw-r--r-- root root index.html
#                      ^^^^^^^^^^ 文件本身是 644 人人可读，但根本走不到这

# 参数
namei -l path        # l = long，显示权限、属主、属组
namei -m path        # 只显示权限
namei -x path        # 用 ? 标记不存在的部分
namei -o path        # 显示属主
namei /path/to/link  # 会把软链接的每一跳都展开显示

namei -l /opt/app/current/bin/server
# f: /opt/app/current/bin/server
# drwxr-xr-x root root  /
# drwxr-xr-x root root  opt
# drwxr-xr-x root root  app
# lrwxrwxrwx root root  current -> releases/v1.2.3       <- 展开了软链接
#   drwxr-xr-x root root  releases
#   drwxr-xr-x root root  v1.2.3
# drwxr-xr-x root root  bin
# -rwxr-xr-x root root  server

# 手工逐层看
d=/var/www/html/index.html; while [ "$d" != / ]; do ls -ld "$d"; d=$(dirname "$d"); done

# 或者用 sudo -u 直接验证某用户能不能访问（最直接）
sudo -u www-data test -r /var/www/html/index.html && echo OK || echo DENIED
sudo -u www-data ls /var/www/html/

mkdir -p /tmp/demo/real/sub /tmp/demo/other
ln -s /tmp/demo/real /tmp/demo/link          # link 是指向 real 的软链接

cd /tmp/demo/link
pwd
# /tmp/demo/link              <- shell 说我在 link 里

cd ..
pwd
# /tmp/demo                   <- shell 认为上一级是 /tmp/demo

cd -P /tmp/demo/link          # -P = physical，先解析成真实路径再进去
pwd
# /tmp/demo/real              <- 直接落到真实目录

cd ..
pwd
# /tmp/demo                   <- 这次上一级是 real 的父目录，恰好也是 /tmp/demo

mkdir -p /tmp/x/deep/dir /tmp/y
ln -s /tmp/x/deep/dir /tmp/y/mylink

cd /tmp/y/mylink && pwd       # /tmp/y/mylink        （逻辑路径）
cd .. && pwd                  # /tmp/y               （shell 按字符串算的）

cd -P /tmp/y/mylink && pwd    # /tmp/x/deep/dir      （物理路径）
cd .. && pwd                  # /tmp/x/deep          （真实的父目录！完全不同）

# 验证：内核（也就是任何外部程序）看到的永远是物理路径
cd /tmp/y/mylink
pwd                # /tmp/y/mylink        <- bash 内建的 pwd，读的是 $PWD 变量
/bin/pwd           # /tmp/x/deep/dir      <- 外部程序，调 getcwd() 问内核
pwd -P             # /tmp/x/deep/dir      <- 显式要物理路径
echo $PWD          # /tmp/y/mylink        <- $PWD 只是 shell 维护的一个字符串

ls -l /proc/$$/cwd
# lrwxrwxrwx ... /proc/1234/cwd -> /tmp/x/deep/dir       <- 内核记的也是物理路径

# ❌ 危险：在有软链接的路径下，用 .. 拼路径可能指向意料之外的地方
cd "$APP_DIR/current"          # current 是软链接
rm -rf ../old_data             # 你以为删的是 $APP_DIR/old_data
                               # 但如果用了 cd -P 或在子进程里执行，可能删到别处

# ✅ 安全：先解析成绝对物理路径再操作
APP_ROOT=$(cd -P "$APP_DIR" && pwd)
rm -rf "$APP_ROOT/old_data"

# 全局改变 shell 的默认行为（很少用，但要知道有）
set -o physical        # 让 cd/pwd 默认走物理模式
set +o physical        # 恢复默认（逻辑模式）
shopt -s autocd        # 顺带一提：直接敲目录名就能 cd 进去

mkdir -p /tmp/p/real && ln -s /tmp/p/real /tmp/p/link
cd /tmp/p

realpath /tmp/p/link                    # /tmp/p/real          解析软链接
realpath -s /tmp/p/link                 # /tmp/p/link          不解析
realpath --relative-to=/tmp /tmp/p/real # p/real               算相对路径
realpath -m /nonexistent/a/b            # /nonexistent/a/b     不检查存在

readlink -f /proc/self/exe              # 当前进程的真实程序路径
readlink -f "$(command -v python3)"     # python3 最终指向哪个版本  ← 排查多版本必用
# /usr/bin/python3.10

# 脚本里获取自身所在的真实目录（标准写法）
SCRIPT_DIR=$(cd -- "$(dirname -- "$(readlink -f "$0")")" && pwd)
#                                        ^^^^^^^^^^^ 先解析软链接，
#            否则脚本被软链接调用时会拿到链接所在目录而不是真实目录

ln -s a b && ln -s b a          # 造一个环
cat a
# cat: a: Too many levels of symbolic links
#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 对应错误码 ELOOP

# 内核的保护：解析一条路径时最多跟随 40 层软链接
cat /proc/sys/fs/... # （这个限制是编译期常量 MAXSYMLINKS=40，不可调）

# 检测环
realpath a
# realpath: a: Too many levels of symbolic links
find /opt -follow 2>&1 | grep -i loop      # find 会报告检测到的环

cd              # 不带参数 = 回家目录（等价 cd ~ 或 cd $HOME）
cd -            # 回到【上一个】目录（在两个目录间来回切最常用）
cd -P dir       # 物理模式进入
cd -e           # 配合 -P：如果 getcwd 失败则返回非零（脚本里防御用）

# 目录栈：适合"临时去别处，办完事回来"
pushd /var/log      # 进入 /var/log，并把当前目录压栈
# ~/project /var/log       <- 打印当前栈
pushd /etc/nginx    # 再压一层
dirs -v             # 带编号查看栈
# 0  /etc/nginx
# 1  /var/log
# 2  ~/project
popd                # 弹栈并回到 /var/log
popd                # 回到 ~/project
cd ~2               # 直接跳到栈里第 2 个（配合 dirs -v 的编号）

# CDPATH：给 cd 加搜索路径（谨慎使用）
export CDPATH=".:$HOME/projects"
cd myapp            # 会在当前目录找不到时，去 ~/projects/myapp
# ⚠️ 坑：CDPATH 里【必须】把 . 放第一个，否则 cd somedir 可能跳到意想不到的地方；
#        脚本里绝对不要设 CDPATH，会让 cd 的行为不可预测

# 现代工具（需安装）：按使用频率智能跳转
# zoxide：z log  -> 直接跳到最常用的含 log 的目录
# autojump / fasd 同类

cd /var/log && cd - && cd -      # 在两个目录间反复横跳
cd -P /opt/app/current           # 进入软链接指向的真实目录
(cd /tmp && ls)                  # ✅ 用子 shell 临时切换，不影响当前 shell 的 cwd

pwd; pwd -P; /bin/pwd            # 三者在有软链接时可能不同
echo $PWD                        # shell 变量，等价 pwd -L
echo $OLDPWD                     # 上一个目录，cd - 用的就是它
readlink /proc/self/cwd          # 内核视角的真实 cwd

findmnt /var/log
# TARGET SOURCE    FSTYPE OPTIONS
# /var   /dev/vdb1 ext4   rw,relatime
#  ^^^^ 说明 /var/log 属于 /var 这个挂载点，不是根分区

# 部署脚本里的防御性检查（数据盘没挂载就往上写，会把根分区写爆）
mountpoint -q /data || { echo "/data 未挂载，中止"; exit 1; }

# 判断两个路径是否在同一文件系统（决定 mv 是否原子、能否硬链接）
[[ $(stat -c '%d' /a) == $(stat -c '%d' /b) ]] && echo "同一文件系统"

pushd DIR       # 压栈并进入
pushd           # 交换栈顶两个目录
pushd +2        # 把栈里第 2 个转到栈顶并进入
popd            # 弹栈并进入新的栈顶
popd +1         # 只删除栈里第 1 个条目，不改变当前目录
dirs -v         # 带编号显示目录栈
dirs -c         # 清空栈

tree -L 2 -d /etc        # 看目录骨架（见 04 篇 10.11）
du -xh -d1 /var | sort -h    # 看哪个子目录大（-x 不跨文件系统）
find / -maxdepth 1 -type d   # 列出根下所有目录