文章 on T.本秋的自留地

简单了解和手动使用 TPM

Tue, 05 May 2026 16:49:51 +0800

最近疯狂迷恋 tpm，这个小玩意究竟是怎么实现基于设备的安全的？

tpm 的相关属性
#

第一步，我们先看下 tpm 有什么变量是可以被改变的：

sudo tpm2_getcap properties-variable

第一组：永久属性组 (PT -> Property)
#

TPM2_PT_PERMANENT:
 ownerAuthSet: 0 # 所有者鉴权密码
 endorsementAuthSet: 0 # 背书鉴权密码
 lockoutAuthSet: 0 # 锁定鉴权密码
 reserved1: 0
 disableClear: 0
 inLockout: 0
 tpmGeneratedEPS: 1
 reserved2: 0

第二组：启动时状态
#

TPM2_PT_STARTUP_CLEAR:
 phEnable: 1 # 平台层级，也就是你可以在系统里面清除tpm所有信息
 shEnable: 1 # 存储层级，其实跟owner是一样的
 ehEnable: 1 # 背书层级
 phEnableNV: 1
 reserved1: 0
 orderly: 1

第三组：句柄资源 (HR -> Handle Resource)
#

TPM2_PT_HR_NV_INDEX: 0x5
TPM2_PT_HR_LOADED: 0x0 # 当前已加载密钥
TPM2_PT_HR_LOADED_AVAIL: 0x3
TPM2_PT_HR_ACTIVE: 0x0 # 已激活的会话
TPM2_PT_HR_ACTIVE_AVAIL: 0x40
TPM2_PT_HR_TRANSIENT_AVAIL: 0x3 # 临时会话，从存储读入内存
TPM2_PT_HR_PERSISTENT: 0x0 # 可以永久存储的槽位
TPM2_PT_HR_PERSISTENT_AVAIL: 0x2

第四组：锁定相关配置
#

TPM2_PT_LOCKOUT_COUNTER: 0x0
TPM2_PT_MAX_AUTH_FAIL: 0xC8
TPM2_PT_LOCKOUT_INTERVAL: 0x0
TPM2_PT_LOCKOUT_RECOVERY: 0x0

第五组：杂项
#

TPM2_PT_NV_COUNTERS: 0x0 # 非易失标志位
TPM2_PT_NV_COUNTERS_AVAIL: 0x8
TPM2_PT_ALGORITHM_SET: 0xFFFFFFFF
TPM2_PT_LOADED_CURVES: 0x3
TPM2_PT_AUDIT_COUNTER_0: 0x0 # 审计日志
TPM2_PT_AUDIT_COUNTER_1: 0x0

不同层级
#

Owner Hierarchy: 你平时用来创建密钥、存储数据的权限。

Endorsement Hierarchy: 涉及设备隐私和证书的权限。

Lockout Hierarchy: “锁定控制”权限，用于控制锁定策略：

允许多少次普通密码尝试后进入锁定模式 (TPM2_PT_MAX_AUTH_FAIL)
被记录下连续失败后，过多久次数才能减一 (TPM2_PT_LOCKOUT_INTERVAL)
进入锁定模式后，过多久才能解锁 (TPM2_PT_LOCKOUT_RECOVERY)

⚠️注意：如果你是在验证以上三种层级的管理密码，比如用 tpm2_clear -C o -c -p 的时候，只有一次机会，失败立即进入锁定模式。

你将被限制到 TPM2_PT_LOCKOUT_RECOVERY 的时间秒数之后才能解锁。这两个时间设成 0，永远解不了，只能清除。

Platform Hierarchy: 唯一不受 DA 限制的密码尝试。但是就算你拿到了权限，除了能够清除所有的密钥和密码，没有任何别的权限。

初始化自己的 tpm 配置
#

清除：tpm2_clear

有的平台可以直接用tpm2_clear -c p清掉，有的不行只能到 bios 里面清。

修改锁定设置：tpm2_dictionarylockout (也叫 DA，dictionary attack)

# 分别对应上面的“锁定层级”的三个变量，下例为windows标准设置
sudo tpm2_dictionarylockout -s -n 32 -t 7200 -l 86400

修改密码：tpm2_changeauth

sudo tpm2_changeauth -c lockout <new_password>

这里有个彩蛋，windows 一开始看到新的 tpm，跟我们一样改完了，直接把钥匙扔了，惊喜吧？

所以你只能重置，然后自己设个密码，好在 windows 不会改你的密码回去。

开始使用
#

创建主密钥，得到一个 tpm 的内存快照，这个主密钥，相比于密钥的说法，其实更是一个 token，因为是由 TPM 这一个生命周期的种子派生的，所以每次用同样的输入得到同样的输出，这里不是指的 ctx 的 hash 相同，而是每次读取的公钥相同。

如果还原了 tpm，签名会变，ctx 永远不再可用。

# 创一个新的
❯ tpm2_createprimary -C o -c primary2.ctx
name-alg:
 value: sha256
 raw: 0xb
attributes:
 value: fixedtpm|fixedparent|sensitivedataorigin|userwithauth|restricted|decrypt
 raw: 0x30072
type:
 value: rsa
 raw: 0x1
exponent: 65537
bits: 2048
scheme:
 value: null
 raw: 0x10
scheme-halg:
 value: (null)
 raw: 0x0
sym-alg:
 value: aes
 raw: 0x6
sym-mode:
 value: cfb
 raw: 0x43
sym-keybits: 128
rsa: c26b4cbadd50e487645f22d72f378953282d9a95036f09815fd91b2fd360f85517e730b19c1ba5668452b4ceca94a38aa6883ba6204f1ea4f72bd644190186fd1806f486e0e9de1ebe4fd64f618a0aac2d120e766bd0575f19b0ecce6ff55df47bacdffb8a431ac8d75cadff88ec62f149ae99ea210da4ba315b2d849b1e2b9196f7baac40ee34382f063e69af448b0c5812319b1efaa7cdffe50d3e4c396e427b270c95676b48168b2b90de555dd1cb46cbdeaed6c4f5c8466fa6a977af67a70efdf673a05b3fe7577bfb7d55991a0b7e94e917fc2533975c13c26231b3d2f6e990c395f963728f3dcaecd8f656f4a5a709fbd5c7edbda773ce960d0c9076c3

# 读一个之前创的
❯ tpm2_readpublic -c primary.ctx
name: 000bf2c2daef8da6f674f7cdd47edb780e14baec9ed14a212904d79ca92c93e05c7c
qualified name: 000b8a569c59019bf73a23befe7aeb9e54c74470737c0288f63d2481324388e1edfb
name-alg:
 value: sha256
 raw: 0xb
attributes:
 value: fixedtpm|fixedparent|sensitivedataorigin|userwithauth|restricted|decrypt
 raw: 0x30072
type:
 value: rsa
 raw: 0x1
exponent: 65537
bits: 2048
scheme:
 value: null
 raw: 0x10
scheme-halg:
 value: (null)
 raw: 0x0
sym-alg:
 value: aes
 raw: 0x6
sym-mode:
 value: cfb
 raw: 0x43
sym-keybits: 128
rsa: c26b4cbadd50e487645f22d72f378953282d9a95036f09815fd91b2fd360f85517e730b19c1ba5668452b4ceca94a38aa6883ba6204f1ea4f72bd644190186fd1806f486e0e9de1ebe4fd64f618a0aac2d120e766bd0575f19b0ecce6ff55df47bacdffb8a431ac8d75cadff88ec62f149ae99ea210da4ba315b2d849b1e2b9196f7baac40ee34382f063e69af448b0c5812319b1efaa7cdffe50d3e4c396e427b270c95676b48168b2b90de555dd1cb46cbdeaed6c4f5c8466fa6a977af67a70efdf673a05b3fe7577bfb7d55991a0b7e94e917fc2533975c13c26231b3d2f6e990c395f963728f3dcaecd8f656f4a5a709fbd5c7edbda773ce960d0c9076c3

加密文字
#

在主密钥下面创建一个子密钥：

echo -n "hello" | tpm2_create -C primary.ctx \
 -u key.pub -r key.priv \
 -i- \
 -p "123456"

生成一个 tpm 的内存快照：

tpm2_load -C primary.ctx -u key.pub -r key.priv -c key.ctx

把它持久化到 tpm 的对象里面：

sudo tpm2_evictcontrol -C o -c key.ctx 0x81010002

有点乱？总结一下

命令说明： tpm2_create 指的是创建一个"密封信件",这个信件有公钥来标识身份，有加密 blob 来给 tpm 读。 tpm2_load 则是让 tpm 读取这个密封信件，他生成一个内存快照 (token)，这个东西可以持久化来被 tpm 引用（成为永久句柄）。 tpm2_evictcontrol 如果-c 加的是文件，然后再跟上地址，语义就是把这个文件持久化到 tpm 的一个句柄中；如果-c 加的是一个地址，那么则是把这个持久句柄驱逐。

对这里出现的文件进行说明：

key.pub 可以开放给别人看
key.priv 是被 tpm 加密的对象，只有 tpm 才能解密
key.ctx 是 tpm 的内存快照，和 0x 开头的是同一个类型的东西，都可以被-c加载

所以我们给他解个密：

❯ tpm2_unseal -c key.ctx -p 123456
hello%
❯ tpm2_unseal -c 0x81010002 -p 123456
hello%

验证签名
#

既然懂了一些，我们就不要用 rsa 了，用 ecc，只需把所有的创建密钥的过程加-G ecc就行。

如果要删除之前的，善用 evictcontrol。

重新创建 ecc 的主密钥：

tpm2_createprimary -C o -G ecc -c ecc_primary.ctx

创建一个签名的对象：

tpm2_create \
 -C ecc_primary.ctx \
 -G ecc256:ecdsa \
 -u ecc.pub \
 -r ecc.priv \
 -p 123456

加载：

tpm2_load \
 -C ecc_primary.ctx \
 -u ecc.pub \
 -r ecc.priv \
 -c ecc.ctx

持久化：

sudo tpm2_evictcontrol -C o -c ecc.ctx 0x81020000

生成一个固定的挑战，用于验证（其实真正的过程中，每次都是不同的）：

head -c 32 /dev/urandom > challenge.bin

用 tpm 自带的工具验证：

❯ tpm2_sign \
 -c 0x81020000 \
 -g sha256 \
 -s ecdsa \
 -o sig.tss \
 -p 123456 \
 challenge.bin
❯ tpm2_verifysignature \
 -c 0x81020000 \
 -g sha256 \
 -s sig.tss \
 -m challenge.bin
# 返回0，通过

整活
#

接下来把这个接入 pam。

导出公钥：

tpm2_readpublic -c 0x81020000 -f pem -o /etc/tpm-ecc.pub.pem
chmod 644 /etc/tpm-ecc.pub.pem

用我这个项目试试，仅供娱乐：

#%PAM-1.0

auth required pam_faillock.so preauth
auth [success=3 default=ignore] pam_tpm_ecc.so key_handle=0x81020000 pubkey=/etc/tpm-ecc.pub.pem
-auth [success=2 default=ignore] pam_systemd_home.so
auth [success=1 default=bad] pam_unix.so try_first_pass nullok
auth [default=die] pam_faillock.so authfail
auth optional pam_permit.so
auth required pam_env.so
auth required pam_faillock.so authsucc

polkit
#

这玩意，搞那么复杂的权限管理，还用模板，没折腾死我。

他每次授权的时候启动一个 helper，这个 helper 有 root 权限，但是启动的时候被 systemd 限制了一大堆特权，我们得用 drop-in 给他加回来：

sudo systemctl edit polkit-agent-helper@

# Editing /etc/systemd/system/polkit-agent-helper@.service.d/override.conf
[Service] 
DeviceAllow=/dev/tpmrm0 rw
BindPaths=/dev/tpmrm0

彩蛋
#

一发入魄：

❯ sudo tpm2_dictionarylockout -s -n 10 -t 600 -l 60
WARNING:esys:src/tss2-esys/api/Esys_DictionaryAttackParameters.c:310:Esys_DictionaryAttackParameters_Finish() Received TPM Error
ERROR:esys:src/tss2-esys/api/Esys_DictionaryAttackParameters.c:108:Esys_DictionaryAttackParameters() Esys Finish ErrorCode (0x0000098e)
ERROR: Esys_DictionaryAttackParameters(0x98E) - tpm:session(1):the authorization HMAC check failed and DA counter incremented
ERROR: Failed DictionaryLockout Setup
ERROR: Unable to run tpm2_dictionarylockout
❯ sudo tpm2_dictionarylockout -s -n 10 -t 600 -l 60
WARNING:esys:src/tss2-esys/api/Esys_DictionaryAttackParameters.c:310:Esys_DictionaryAttackParameters_Finish() Received TPM Error
ERROR:esys:src/tss2-esys/api/Esys_DictionaryAttackParameters.c:108:Esys_DictionaryAttackParameters() Esys Finish ErrorCode (0x00000921)
ERROR: Esys_DictionaryAttackParameters(0x921) - tpm:warn(2.0): authorizations for objects subject to DA protection are not allowed at this time because the TPM is in DA lockout mode
ERROR: Failed DictionaryLockout Setup
ERROR: Unable to run tpm2_dictionarylockout

UPS 折腾记

Wed, 22 Apr 2026 23:00:09 +0800

前言
#

最近我突然有了两台 ups 的管理权，一台工作室的 APC Smart-UPS SPRM1K，另一台家里的 APC BACK-UPS BK650。由于手边只有前者，先更新前者的研究成果，后者择日更新。

管理带通信的 UPS 的配套软件其实就两种，这里主要讲解 NUT，而 apcupsd 配置很简单，而且也可以作为 NUT 的驱动，这里不再详述。

NUT 的配置
#

要理解 NUT，首先要明白几个概念：driver、monitor(client)、server（可选），三个服务都要单独启用。

驱动层
#

driver 其实就是对接各种奇奇怪怪 ups 的，这里我这两台一个用的是串口（apcsmart）,另一个是 usbhid-ups，这里主要是以前者讲解的。

配置 ups 驱动：

## /etc/nut/ups.conf 
## 根据需要填写,可用nut-scanner -U获取驱动
[ups]
 driver = apcsmart
 port = /dev/ups
 cable = 940-0024
 ignorelb # 手动指定阈值
 override.battery.charge.low = 70
 override.battery.runtime.low = 20

启动服务：upsdrvctl start。

这里有个小插曲，串口可能提示权限不够：

root@pve:/etc/nut# upsdrvctl start
Network UPS Tools - UPS driver controller 2.8.1
Network UPS Tools - Generic HID driver 0.52 (2.8.1)
USB communication driver (libusb 1.0) 0.46
libusb1: Could not open any HID devices: insufficient permissions on everything
No matching HID UPS found
upsnotify: notify about state 4 with libsystemd: was requested, but not running as a service unit now, will not spam more about it
upsnotify: failed to notify about state 4: no notification tech defined, will not spam more about it
Driver failed to start (exit status=1)

用 udev 规则，给 nut 权限：

cat << 'EOF' > /etc/udev/rules.d/99-nut-ups.rules
SUBSYSTEM=="usb", ATTR{idVendor}=="051d", ATTR{idProduct}=="0002", MODE="0660", GROUP="nut"
EOF
udevadm control --reload-rules
udevadm trigger

再次启动：upsdrvctl start

服务层
#

nut 其实 c/s 架构很分明，如果只有一台机子，也得启动一个服务器。但是这也为拓展型带来了便利。

如果你只有一台机子，用 standalone 即可，作为“吹哨人”，用 netserver，接收命令关闭自己的机器，用 netclient。

我这里改成服务器：

## /etc/nut/nut.conf
# 服务器模式
MODE=netserver

## /etc/nut/upsd.conf
# 加上这一行，给局域网里面的设备提供服务
# 如果你是pve而且路由器不接ups，建议自己建一个
# 自定义交换机
LISTEN 0.0.0.0 3493

配置用户，monuser 最好有，因为群晖用这个而且不能更改。

## /etc/nut/upsd.users
[monuser]
 password = secret
 upsmon slave
[admin]
 password = <your_password>
 upsmon master
 actions = SET
 instcmds = ALL

启动服务：systemctl enable --now nut-server

客户端/监视层
#

配置 nut-monitor 以便自动关机：

MONITOR ups@localhost 1 monuser secret master # slave也可以，后文（关机过程）讲

你可以看到，最下面有个shutdown命令，这个只要 monitor 服务启动了，在遇到低电量阈值的时候，就一定会执行的。

启动服务：systemctl enable --now nut-monitor

关机过程
#

断开电源，nut 检测到电池供电，其他客户端收到信号。

对于群晖这种设置了 upssched 的机子，他可以在检测到断电之后的一定时间开启安全模式（umount 所有分区，只保留必须的 nut 监听服务和关机逻辑），如果在此期间市电恢复，重新检测到后会进行自动重启。

电池到达所给定的阈值（电量/剩余事件/电池供电时间），发出警告信号。

这时候服务器自己会开始关机（执行 shutdown），其他客户端会收到信号，开始进行关机。

在关机最后一刻，有一个有意思的脚本想和大家分享。

这个脚本是 systemd 在关机的最后时刻执行的，位于/usr/lib/systemd/system-shutdown/nutshutdown。我们来看看他的结构：

#!/bin/sh

# This script requires both nut-server (drivers)
# and nut-client (upsmon) to be present locally
# and on mounted filesystems
[ -x "/sbin/upsmon" ] && [ -x "/sbin/upsdrvctl" ] || exit

if /sbin/upsmon -K >/dev/null 2>&1; then
 # The argument may be anything compatible with sleep
 # (not necessarily a non-negative integer)
 wait_delay="`/bin/sed -ne 's#^ *POWEROFF_WAIT= *\(.*\)$#\1#p' /etc/nut/nut.conf`" || wait_delay=""

 /sbin/upsdrvctl shutdown

 if [ -n "$wait_delay" ] ; then
 /bin/sleep $wait_delay
 # We need to pass --force twice here to bypass systemd and execute the
 # reboot directly ourself.
 /bin/systemctl reboot --force --force
 fi
fi

exit 0

可以注意到经过一系列的判断，如果是真的断电（发出警告后）upsmon -K会返回 1，那么就会使用upsdrvctl shutdown来命令 ups 在一定时间后断电。

但是这时候，系统已经解除了所有的磁盘 rw 的挂载，执行完脚本的下一步其实就是给 acpi 电源发送 S5 信号并断电，速度很快，其实断不断电也无所谓了。

一般的断电延时 20s 绰绰有余。至于断电时间的设置，高级的 ups 可以设置（见后文upsrw），普通的不可以。

所以如果这是最后一个“吹哨人”执行的 killpower（让 ups 等会断电），最好关闭的时候要尽量比 slave 关得晚，否则就得尽量延长 ups 的延迟时间。

常用命令
#

upscmd：执行一些驱动预设的指令
#

root@SAST-Docker:~# upscmd -l ups
Instant commands supported on UPS [ups]:

bypass.start - Put the UPS in bypass mode
bypass.stop - Take the UPS out of bypass mode
load.off - Turn off the load immediately
load.on - Turn on the load immediately
shutdown.return - Turn off the load and return when power is back
shutdown.stayoff - Turn off the load and remain off
test.battery.start - Start a battery test
test.battery.stop - Stop the battery test
test.failure.start - Start a simulated power failure
test.panel.start - Start testing the UPS pane

upsrw：用于读写 eeprom 的
#

使用：

upsrw -l <upsname>

控制响声、复电延迟启动、复电要求电池水平、关电延迟停止 ups。

比如我们工作室的 SPRM1K 可以设置的东西就很多，还贴心的用了 enum 告诉你：

root@SAST-Docker:/etc/nut# upsrw -l ups
[battery.alarm.threshold]
Battery alarm threshold
Type: ENUM NUMBER
Option: "0" SELECTED
Option: "T"
Option: "L"
Option: "N"

[battery.charge.restart]
Minimum battery level for restart after power off (percent)
Type: ENUM NUMBER
Option: "00"
Option: "15"
Option: "50" SELECTED
Option: "90"

[battery.date]
Battery change date
Type: STRING
Maximum length: 8
Value: 12/30/25

[input.transfer.high]
High voltage transfer point (V)
Type: ENUM NUMBER
Option: "231"
Option: "242"
Option: "253"
Option: "264" SELECTED

[input.transfer.low]
Low voltage transfer point (V)
Type: ENUM NUMBER
Option: "187"
Option: "176" SELECTED
Option: "165"
Option: "154"

[output.voltage.nominal]
Nominal output voltage (V)
Type: ENUM NUMBER
Option: "220" SELECTED
Option: "230"
Option: "240"

[ups.delay.shutdown]
Interval to wait after shutdown with delay command (seconds)
Type: ENUM NUMBER
Option: "020"
Option: "180"
Option: "300" SELECTED
Option: "600"

[ups.delay.start]
Interval to wait before (re)starting the load (seconds)
Type: ENUM NUMBER
Option: "000"
Option: "060" SELECTED
Option: "180"
Option: "300"

[ups.id]
UPS system identifier
Type: STRING
Maximum length: 8
Value: UPS_IDEN

[ups.test.interval]
Interval between self tests (seconds)
Type: ENUM NUMBER
Option: "1209600" SELECTED
Option: "604800"
Option: "0"

我在这里改了ups.delay.shutdown，原因很尴尬，esxi 只支持客户端模式的 nut，服务端只能用一台虚拟机来实现。那么希望在服务端发出 killpower 后，还能等待 esxi 关闭，这个时间就不可避免的延长。

我还改了ups.delay.start，这个参数很有意思，他没有注释，根据字面意思理解，应该是断电之后延迟启动吧？

但是不是这个意思。他指的是如果你发出了 killpower 的命令后中途来电，他断电后，应该在多少秒后开机？

我觉得这句话得细品。

对于我这台 SPRM1K 来说，发送 killpower 指令后，首先是等待ups.delay.shutdown的时间，然后切断输出，然后过了硬编码的 1 分钟，关闭 ups 自己。

那么就有几种情况：

在等待ups.delay.shutdown时，市电恢复。
在等待硬编码的 1 分钟的时候，市电恢复。
ups 关机之后，市电恢复。

这三种情况中前两者会等待ups.delay.start的时间，最后一种不会等待，初始化之后直接开机。

我想应该是这篇文章里面提到的问题，作者说如果断电的时间太短，那么 After AC Loss 就算设置为 Power On，也不一定能自动开机。所以才有这么一个选项。

btw: 我并不太赞同链接里面的方案，复杂度太高了很难维护，其实里面很多东西厂家已经做好了。（排除 UPS 不够高端的问题，这个等我回去测试一下我的 BK650 再下定论）

奇怪的 bug
#

根据 man 8 usbhid-ups 中的说明，可以直接在 ups.conf 里面配置 allow_killpower 来在启动的时候生效，但是这个 issue 说 allow_killpower 在 2.8.3 之后才修复启动的时候硬编码的 0 会覆盖回去的问题，然而 trixie 是 2.8.1，就很难受。

能用点 hack 的办法，启动的时候修改。

systemctl edit nut-driver@ups.service
# 写入
[Service]
# 延迟几秒确保驱动已经完全初始化
ExecStartPost=/bin/sh -c "sleep 5 && /usr/bin/upsrw -s driver.flag.allow_killpower=1 -u admin -p <你的密码> ups"

但是这台设备不再身边，所以我还是选择了保守的 apcupsd 方案关机+nut 桥接给群晖，这篇文章之后还会更新的。

Immortalwrt：多线多网与 Tailscale

Wed, 07 Jan 2026 01:42:21 +0800

配置多线多内网
#

现在我同时有了两个账号的使用权，一个是运营商账号，有 IPv6，但是速度不算快，不过不断网；另一个是运营商自建的网，卖给学生用的，没有 IPv6，晚上 11 点半还断网，真是花钱做大冤种啊哈哈！

那么就有了配多内网的想法，之前也划过 VLAN 了，这里就不赘述了，提一嘴怎么给电脑网卡变成 trunk 模式，Win 就是在设备管理器，网卡的高级设置里面填入 ID，Linux 先 modprobe 8021q，用 nmcli 可以添加子接口，具体看一下 manual。

在接口 - 设备这里，可以创建 MAC VLAN:

需要注意的是，在这台京东云上面要求多个 MACVLAN 必须是连续的，否则可能出现设备 CLAIM 失败的报错。

然后使用 curl --interface 分别给每个接口配置 portal 认证。现在应该有两个接口了：

这时候会自动把两个 wan 口下发的路由都加到 main 表里面，是什么顺序我没注意，不过，你的设备肯定只走一条出去，另一条是闲置的。

所以我们要在高级设置里面覆盖 IPv4 路由表，这个的意思是把获取到的路由加到这个表里面。

表分两种，有名字的和纯数字 ID 的。你这里只能填 ID，填完了可以到 /etc/iproute2/rt_tables 里面按照 id 名字 这样写，这时候就更加有可读性。

/etc/iproute2/rt_tables 必须是连续的，否则可能出现设备 CLAIM 失败的报错。

然后使用 curl --interface 分别给每个接口配置 portal 认证。现在应该有两个接口了：

这时候会自动把两个 wan 口下发的路由都加到 main 表里面，是什么顺序我没注意，不过，你的设备肯定只走一条出去，另一条是闲置的。

所以我们要在高级设置里面覆盖 IPv4 路由表，这个的意思是把获取到的路由加到这个表里面。

表分两种，有名字的和纯数字 ID 的。你这里只能填 ID，填完了可以到 /etc/iproute2/rt_tables 里面按照 id 名字 这样写，这时候就更加有可读性。

那么我就把两个路由分到了两个路由表里面，一个 cmcc，另一个 cernet。

这时候问题来了，你多半发现上不了网了，原因是默认只会查主路由表（main），这时候主路由表里面只有你的内网 local 路由，发往别的网段的数据包就被丢弃了。

所以我们得手动定制路由规则，其实对应的就是 ip rule 命令了。

按照不同的网段查不同的表，请注意上面两条规则很重要，要不然内网的流量也被发到 wan 口去了，wrt 系不像 routeros，没有靠 MAC 地址连接的办法，自动回滚居然也不生效，没备份的我至少重新弄了三遍。

然后就可以爽用了。

tailscale 出现的问题
#

配完过了几天发现外部的 tailscale 没法连到内网的设备了，tcpdump 一看，只有访问的包，没有回去的包。我当时以为是 masquerade 的问题，在 ts 接口上面开了动态伪装，然后 dump br-lan.2，发现其实内网有回复，但是发到路由器后就没下文了。

我立马就知道肯定是路由规则问题了，防火墙没问题。

于是添加了一条最优先的规则，让目标为 `100.64.0.0/10’ 的走主路由表，还是不通。

其实还是先入为主了！ts 自己弄了个 52 的路由表，他的规则全部在里面，根本不在主路由表。高级设置里面表填上 52，收工！

Dbus 探索

Fri, 21 Nov 2025 17:56:21 +0800

前言
#

之前想使用 syfs 监听电量变化失败，原因是 sysfs 不支持 epoll 之类的高级特性，所以还得隔几秒轮询，这对于精确度要求高的我来说是没法接受的，所以我不得不望向一个很熟悉但是陌生的东西————Dbus。

概念
#

感觉 Dbus 是有点点像 MQTT，你看 broker 都出来了，都有订阅这一说法，但是又有点不同。

总线: 包括系统总线和用户总线。前者可以报告系统状态，硬件上的状态（正是我们需要的）；后者则在 KDE 的通知和特效之类上面大量使用，比如录屏的时候静音之类。
总线名称: 一个跟 Dbus 有关的服务启动了，这个服务下面提供的各种对象，全都是挂在这个总线名称下的。
对象路径: 服务提供的某些功能/实例，有点像 unix 的路径但是完全不一样，组织成面向对象的层次结构。
接口名称: 一个服务可以有多个接口，在不同的接口名称定义对象提供的方法、属性和信号。
- 方法: 客户端向服务端发起的同步请求，要求服务执行请求/获取状态然后返回请求。
- 属性: 客户端向服务端可以获取到的状态。
- 信号: 服务向总线上面发送通知，告知感兴趣的客户端某个事件发生了。
订阅: 客户端告诉总线对服务上面的某个对象的某个信号感兴趣。

systemd 和 Dbus 集成挺好的，可以监听某个总线上面的连接，如果客户端发出了请求但是服务没有启动，那么就会自动启动服务。这就像普通的服务上面的 socket 按需启动一样，也是把这套思路应用到了 Dbus 上面。

一般来说约定名字和对象路径中间的 . 和 / 对应，但是当然可以不遵守。

客户端可以手动向服务查询，对于用户，可以手动通过命令行获取信息；也可以由服务通过信号推送得到信息，这样就避免轮询造成的性能开销。

命令行使用
#

systemd 的 busctl 比较好理解，以这个工具为例。

busctl 无非就那几个参数，总线名称，对象路径，接口名称，然后按需调用/获取对应的对象。

自省
#

busctl introspect <busName> <path>

如果这个路径下的对象允许被自省的话，比如说 UPower：

❯ busctl introspect org.freedesktop.UPower /org/freedesktop/UPower
NAME TYPE SIGNATURE RESULT/VALUE FLAGS
org.freedesktop.DBus.Introspectable interface - - -
.Introspect method - s -
org.freedesktop.DBus.Peer interface - - -
.GetMachineId method - s -
.Ping method - - -
org.freedesktop.DBus.Properties interface - - -
.Get method ss v -
.GetAll method s a{sv} -
.Set method ssv - -
.PropertiesChanged signal sa{sv}as - -
org.freedesktop.UPower interface - - -
.EnumerateDevices method - ao -
.GetCriticalAction method - s -
.GetDisplayDevice method - o -
.DaemonVersion property s "1.90.10" emits-change
.LidIsClosed property b false emits-change
.LidIsPresent property b true emits-change
.OnBattery property b false emits-change
.DeviceAdded signal o - -
.DeviceRemoved signal o - -

调用方法
#

那么显而易见了，直接调用：

busctl call <busName> <path> <interface> <object> [param]

得是 method 才能被调用，有的方法需要参数才能调用。

属性
#

属性既可以获取，在有权限的情况下可以设置。

busctl get-property <busName> <path> <interface> <object>
busctl set-property <busName> <path> <interface> <object>

签名
#

获取对象或者调用方法传参的时候，要求签名匹配。这里其实是一些数据类型，根据对应的英文简称：

s: 字符串
b: 布尔
i: 整形
u: 无符号整形
d: 双精度
(a)o: （数组式的）对象路径，用于查看其他对象。

传入参数是这样的，先输入类型，然后跟上你的数据，比如：

s "hello" i 32

简单的电量检测小工具
#

让 Gemini 用 QT 写了一个简单的电量监测系统，仅用于我这一台 chromebook：

BatteryService

现代 C++ 笔记：I/O 流与字符串流

Thu, 13 Nov 2025 13:58:39 +0800

流
#

`std::cin >>`
#

跳过输入流中前导空白符，当遇到下一个空白的时候停止，并把空白保留在输入缓冲区中。

简单来说，就是获取一个单词。

C-style 的函数
#

有一些函数是 C 遗留下来的，所以他们不支持 std::string，只能使用传统的 C 风格字符串。

std::getline()

给定一个字符串缓冲的容器：

获取缓冲区的内容，直到遇到 \n，把 \n 以及前面的内容提取，然后不将 \n 放在目标中。

重载函数 (strBuf, n) 可以提取指定的长度的字符，获取 n -1 个字符，因为要有 \0 结尾。

gcount() 用于统计提取的部分，包括 \n，但是不包括限定长度在后面添加的 \0。

现代 C++ 笔记：继承、虚函数与异常处理

Thu, 06 Nov 2025 10:23:35 +0800

继承，派生
#

继承初始化
#

在构造函数后面的 : 加入基类的列表初始化：

class Base {
 private:
 int m_baseVar{};

 public:
 Base(int baseVar) : m_baseVar{baseVar} {}
};
class Derive : public Base {
 private:
 int m_deriveVar{};

 public:
 Derive(int baseVar, int deriveVar) : Base{baseVar}, m_deriveVar{deriveVar} {}
};

修改派生类的访问权限
#

访问修饰符
#

定义派生类的时候，: 后的访问限定符：

public: 基类所有访问类型，即为派生类的访问类型。
protected: 基类的 public 在派生类中是 protected。
private: 基类的 public 和 protected 在派生类中是 private。

基类的 private 在派生类中默认永远无法访问。

`using`来强制改变单个成员
#

可以单独在派生类中修改基类中可访问的成员在派生类的访问权限。

class Derive : public Base {
 private:
 using Base::func; // 假设这两个在 Base 都是公开的
 using Base::m_var;
}

这样就把两个成员在派生类中限制在了 private 权限，重载函数会全部限制。

隐藏功能
#

如果基类和派生类存在同名的成员函数，那么派生类会隐藏基类的函数。

如果向派生类对象传入一个 int，基类里面的匹配 int，派生类匹配 double，还是会优先使用派生类的函数，然后通过数值转化把实参变成 double。

解决方案是在派生类强制使用 using Base::func 来使用基类的函数。

删除功能
#

像复制构造函数一样，可以显示删除某些不需要的基类功能，用 = delete。

但是仍然可以绕过派生类访问基类的功能：

std::cout << derived.Base::m_value;
std::cout << static_cast<Base&>(derived).m_value;

虚函数
#

虚函数是 RTTI（运行时类型信息）的典型代表。

在多个派生的类中，如果有签名一致的函数，前面加上 virtual 关键字，如果有类型为低派生的引用或者指针指向高派生的类，那么使用该指针将会自动调用尽可能高派生的类的函数。

如果一个派类在其继承链的中只要有一个类的函数是 virtual，那么其所有相同签名的函数均视为虚函数。

覆盖
#

使用 override 关键字在派生类中显式的覆盖相同签名的函数，如果无法覆盖会报错，这样避免了签名不一致导致未覆盖还过编译的情况。

override 放在成员函数的 const 后。

override 是隐式 virtual 的，所以只有最底层的基类型需要 virtual 关键字，其他都可以写 override。

final 放在 override 后，提示这是最后一个覆盖的派生类函数，后续派生的类若再覆盖，则报错。

协变返回类型
#

当派生类中返回一个 this 指针的时候，这个指针指向的类型只跟调用它的引用/指针类型有关。

虚析构函数
#

如果使用低层的引用/指针指向一个高层的派生类，释放的时候不会正确调用高层的析构函数。此时需要给析构函数添加 virtual 修饰符。

不推荐给所有的派生类添加 virtual，因为虚函数表会造成开销。如果不希望此类被继承，应该在定义类的时候在类名后添加 final 禁用对此类的继承。

绑定和调度
#

早期绑定/早期调度：在编译的时候就已经确定了调用函数的地址。
晚期绑定：使用函数指针调用函数
晚期调度：调用虚函数，通过虚表查询，只有在运行时才知道真正调用的函数。

纯虚函数，纯虚类，虚基类
#

纯虚函数指的是基类声明了有这个函数，但是实际上无法实例化，只能交由派生类实例化的函数。

在一个 virtual 后面加入 = 0 即可实现，也不需要函数体。

纯虚类（抽象类）其实相当于一个接口函数，这个类没有成员变量，只有纯虚函数，需要注意必须要有虚析构函数。此类不能被构造，一般在调用的时候，形参为其的引用/指针，并接受其派生类为实参。

虚基类在继承的 : 后面加入 virtual，目的是只有最后一个非虚的派生类创建对象，从而避免菱形继承造成的功能重复。

切片
#

当复制/移动的的目标类型是基类型时，会造成切片，只保留基类实例的部分。

RTTI
#

`dynamic_cast`
#

用于向下转换（把一个基类型的指针转换成一个派生类型的指针），造成很大的开销，转换后需要判断是否转换成功。

当然用 static_cast 也可以转换，但是不会判断是否是否可以成功转换，访问的时候会造成内存问题。所以不推荐。

`typeid`
#

获取表达式和类型的类型信息，用于实现 C++ 中的自省。

重载的运算符 ==，用于比较两个对象是否完全一致。

成员函数 .name()，可被打印的、修饰过的编译器名字。

委派重载函数
#

<< 不能够被设置成虚函数，因为不是成员函数。但是可以委派给虚函数来打印，只需要把流对象的引用传递过去即可。

异常处理
#

经典的 try-catch 块和 throw 关键字。

在主函数里面使用 try 包裹功能调用函数的时候，函数也可以抛出异常，如果函数本身没有处理，会清理本块的资源，然后依次交由上一级调用栈处理，这个过程叫作栈展开。如果一直到主函数都没有处理，那么就会调用 std::terminate() 终止程序，此时可能未完成清理。

因此，建议使用 catch(...) 在最后捕获所有异常，此时可以保证所有资源都被清理。

析构函数是隐式 noexcept 的，因为如果析构函数又抛出异常（二次异常），那么程序将会直接终止。

异常类和重载不同，对于能同时接受派生类和基类的形参，会优先选择第一个 catch，所以需要把最匹配的放在前面。

异常对象的存储机制
#

异常对象会在抛出的时候进行复制，所以这个对象的类必须有复制构造函数，才能正常进行异常流程。

在 `catch` 中抛出异常
#

可以在 catch 中抛出异常，如果希望再次抛出相同的异常向上处理，应该直接使用 throw; 而不是显式指定传入的名字，因为按值复制的过程会造成类型切片。

函数级异常
#

严格在函数的 () 后写 try-catch 块，此过程有隐式重抛异常，最好自己手动指定。

一般用于构造函数中。


class B : public A {
 public:
 B(int x)
 try
 : A{x} // note addition of try keyword here
 {
 } catch (...) // note this is at same level of indentation as the function itself
 {
 // Exceptions from member initializer list or
 // from constructor body are caught here

 std::cerr << "Exception caught\n";

 // throw; // rethrow the existing exception
 }
}

`noexcept`
#

没有带 noexcept 的函数都是潜在的抛出异常的函数。

要求带有此标记的函数，必须在这个块前完成异常处理，如果超出了这个块，那么整个程序就被强行终止（使用 std::terminate）

使用 noexcept 允许编译器进行深度的优化，因为不需要考虑异常的栈展开机制。

`std::move_if_noexcept`
#

在编译的时候确定移动构造函数是否有 noexcept 关键字，如果没有，就 fallback 到复制。

其实此函数传入的形参是可变的，如果移动构造保证无异常抛出，那么就传入将亡值，使用移动构造函数；如果没有，那么就传入左值，使用复制构造函数。

Linux Swap：ZRAM、ZSWAP 与内存策略

Sat, 01 Nov 2025 21:57:31 +0800

引子
#

无论在哪个安装 Arch 的教程里面，你都能看到要求你设置一个 swap 分区，但是，这个分区真的那么有必要吗？

我最早听到 swap 这个字，大概是安卓 2.3-4.0 时代吧。那时候的 CPU 性能不行，存储性能也很差，但是人们却执着于把 swap 放在存储卡上面，总共 128M 的内存，要在卡上放 64M 进行交换。不过对于本来就慢的安卓手机，能够有更大的内存以便运行大型一点的游戏，就算慢一点，也比较值得。

然而在现代系统上面，手机厂商又把这个“内存拓展”拿出来，许多人对此嗤之以鼻，然而这完全不是一回事。

把内存变小，而不是放到低速存储上面
#

首先，能够实现这一切的前提，是内存虚拟化。

一个程序看到的大量的地址空间，其实并不是 1:1 的映射到物理内存上面的。通过系统调用 mmap，操作系统记录了一个程序看到的内存是怎么对应到物理内存上去，但是，为什么一定是物理内存上面呢？

于是有了 swap，当我内存不够的时候，直接把程序运行时的内存（匿名页）驱逐到 swap 上面，然后往映射表记录，当再次需要访问他的时候，触发一个“缺页中断”，就把 swap 的内存重新搬回物理内存上面，这一切对于程序来说都是透明的。

随着性能的发展，人们发现，这个把匿名页搬回物理内存的过程实在是太慢了，浪费了大量的 CPU 时间，那么为什么不让做点事情？于是，内存压缩出现了。

ZRAM
#

ZRAM，顾名思义，就是把内存压缩。

不过，人们用的还是 swap 的那套思路，把内存中的一部分划分出来，然后创建一个块设备，然后需要的时候，把内存压缩进去，这就是 ZRAM。

我们可以通过 swappiness 参数，控制操作系统内核把内存压缩进入 swap 的激进性，现在的值取 0-200 了，值越高，越倾向于把内存放入交换分区。如果是传统的 swap，那么我们希望不要那么激进，因为磁盘总归是慢的；但是对于一个压缩的内存块来说，应该把这个值取很高，因为对于 zstd 和 lz4 这样的算法来说，压缩/解压的速度非常快。

存到极限
#

如果内存的压力持续增大，ZRAM 会有用完的时候。这又分为两种情况：

1. `ZRAM` 达到了设置的压缩前的数据的最大值。
#

这时候如果没有配置回写块的时候，系统就会去寻找一个优先级更低的 swap 了。如果没有，那么就很可能触发 OOM。

配置了回写块的话，ZRAM 会把其中最少使用的数据驱逐到回写块中。这个回写块跟 swap 是不相容的，只能用于一种用途。

如果这时候需要提取写入到回写块中的数据，那么就直接从磁盘解压到物理内存中，因为是压缩的数据，不仅减少了对磁盘的读写，还不让 CPU 闲着。

2. `ZRAM` 还没满，但是物理内存就要满了
#

这种情况一般是 ZRAM 块最大值太高了。

同样也会造成 ZRAM 往回写块驱逐匿名页，但是如果回写块写入很慢造成了阻塞，同时内存占用还在增加，那么操作系统可能就触发 OOM 开始杀进程了。

ZSWAP
#

还有另外一种技术，但是我之前都没听说过。

这项技术配置起来感觉更加 native 一点，因为是直接往内核参数里面写。

ZSWAP 其实不会创建一个块，但是需要 swap 的存在，当系统打算往 swap 里面写入数据的时候，ZSWAP 会拦截写入，然后进行压缩到内存中的一部分区域。

ZSWAP 同样会在内存压力高的时候驱逐匿名页到 swap 中，这一点跟 ZRAM 不一样，因为如果长期 ZRAM 占满，那么系统就会转而使用磁盘 SWAP 交换，此时变慢会变得很明显（尤其是磁盘速度较慢的时候）。

从 Linux 6.8 开始，支持禁用回写块，仅仅用作内存压缩。

所以你会发现，ZRAM 加上了回写块，那么就是普通的 ZSWAP；如果 ZSWAP 禁用了回写块，那么就相当于一个普通的 ZRAM，从使用的角度，确实是这样的。

如何选择
#

既然这两者都可以在使用时相互替代，那么究竟如何选择呢？

桌面环境
#

如果内存足够，更推荐使用 ZSWAP。

如要使用休眠，可以考虑禁用回写块。这样 swap 就专注于配置休眠，但这样负载高了就更容易出现 OOM，这点需要权衡，一般也不会跑大型任务的时候考虑休眠吧？

其他环境
#

小内存的设备，比如安卓，更加倾向于 ZRAM。原因是 ZSWAP 要求真实的 SWAP 设备，但是闪存一般来说没那么耐写。

服务器可以使用 ZRAM 加上一个小 SWAP，这样可以很好的避免了内存使用的尖锋，也享受了内存压缩的红利。

不推荐同时使用 ZSWAP 和 ZRAM，这样会造成冲突。

两者有什么优势呢？

ZSWAP：管理起来更直观，对于桌面体验来说更加友好。因为是钩子，所以不会出现一个 swap 块。

ZRAM：更适合小内存闪存不可多写的设备。不仅仅是内存压缩，实际上块设备可以格式化来存东西。

观察
#

这是一个 ZSWAP 的 htop 图，compressed 和 frontswap 就是 ZSWAP 工作的事实。

通过简单的计算可以得到压缩率是 26.3%，这也是配置 zstd 的典型压缩率范围。

前置压缩虽然其实占用的是内存中的空间，但是这里算在 swap 里面了， used 里面的 457M 不包括前置交换，由于使用 systemd 禁用了 ZSWAP 使用系统交换空间，所以这里面的内容其实是内核使用的交换空间。

如果是一个 ZRAM 的设备，那么 htop 甚至可以单独调出一条来显示它，从观察角度来说，ZRAM 相对方便一些。

参考
#

(电源管理/挂起与休眠 - Arch Linux 中文维基)[https://wiki.archlinuxcn.org/wiki/%E7%94%B5%E6%BA%90%E7%AE%A1%E7%90%86/%E6%8C%82%E8%B5%B7%E4%B8%8E%E4%BC%91%E7%9C%A0#Disable_zswap_writeback_to_use_the_swap_space_only_for_hibernation]

现代 C++ 笔记：移动语义、智能指针与值类别

Thu, 30 Oct 2025 14:34:07 +0800

左右值、`&&`、移动语义、智能指针
#

有两个重要概念需要区分：

类型 (Type)
#

表示一段内存究竟是怎么样的性质。对于一段内存，它内部的结构应该是怎么样被解析的，使用什么样的运算符。

其实就是一开始的类型系统，包括基本类型的 int、double，也可以是标准库中的 std::string，用户在 class 定义类型。

值类别 (Value Category)
#

在移动语义后完善的概念，重点关注此表达式本身的性质，具有什么身份，是否可以被移动。

在 C++98，只有左值和右值。

但是在 C++11，我们引入了移动语义，出现了一个将亡值。

将亡值有身份可以取地址，但是马上被移动也就消失了，所以我们扩大了左值的定义，认为他是广义左值；

同时，因为他即将消失，所以认为是右值，那么就把以前的右值定义为纯右值，这样五种值类别就出来了。

`&&`/`&` 作为函数形参
#

考虑下面这个函数：

int main(){
 int&& ref{ 5 };
 fun(ref);
}

给出两个 fun 的函数声明：

void fun(int&&);
void fun(const int&);

事实上，只有第二个能够匹配传入的参数，而不是第一个。

在没有引用的时候，我们的函数形参其实是匹配对象的类型的，因为只有确定了类型，函数内部才知道这个对象使用哪一种操作符，如何解释这一段内存。

引入引用之后，带 & 的参数会解释这个对象如何绑定到实参：

左值引用：只能绑定到左值。
常量左值引用：能绑定到左值和右值，如果直接绑定到右值，会延长该对象的生命周期。
右值引用：绑定到右值时，在函数内部转换成一个左值；绑定到左值时，是一个左值引用。

但是需要注意一点，虽然 ref 是一个 int&& 类型的对象，但是他的值类别其实是一个左值，所以形参可以是一个 (常量) 左值引用。

`&&` 在模板参数的使用
#

仅在模板以及泛型中，&& 才有引用折叠作用，常用于完美转发。

最常见的在于这样一个泛型函数：

template <typename T> wrapper(T&& arg){
 target(std::forward<T>(arg))
}

传入左值的时候，会被折叠成 T&，而传入右值的时候，保留 T&& 的类型，&&非常智能，自动判断左右值。

实现移动
#

std::move() 返回的值是一个将亡值 (xvalue)，至于如何把这个值移动，是类的移动构造函数/移动赋值运算符实现的。

所以如果手动编写的移动构造函数/移动赋值运算符，需要注意：

加上 noexcept 关键字，避免抛出异常（要么成功，要么终止，避免移动一半），避免回退到复制。
手动把地址给到目标，然后把原来的指针指向空指针。
对于运算符，可以加上判断一下不是自己给自己，如果是就返回 *this。

至于源对象如何释放，是取决它本身的生命周期的。此时我们已经完成了所有权的转移。

智能指针
#

`unique_ptr`
#

这个指针指向的堆内存必须是它独占的，如果使用移动语义来赋值的话，会自动把上一个指针置空。

不要用一个裸指针来初始化一个智能指针，虽然语法上成立，但是语义上会破坏 unique 的独占性，仍然会发生双重释放的问题。

使用 make_unique 将一个纯右值的对象变成独占的指针，不用手动 new 故比较推荐。

make_unique 其实是一个函数，为一个纯右值返回一个独占指针，所以返回值一定会有一个指针接收，一般用 auto 配合效果很好：

auto ptr {std::make_unique<Fraction>(Fraction{3, 5})};

如果要求传入一个类型的裸指针，但是手上只有智能指针，可以使用 .get() 来得到一个底层中使用的裸指针的副本。

`shared_ptr` 和 `weak_ptr`
#

共享指针允许多个指针同时指向一块内存，同时其内部会保存指向这段内存的计数。当最后一个共享指针销毁的时候，内存将会被自动释放。

不过 shared_ptr 会导致两个共享指针相互依赖的问题，这样在释放的时候认为是互相依赖使得最终内存无法释放导致内存泄漏。

最典型的例子就是，在一个类中有 shared_ptr 的成员变量，然后两个实例化的对象的共享指针指向对方，同时具有相同的生命周期，这样释放的时候互相认为对方存在，从而都不释放内存。

因此，weak_ptr 出现了。弱指针不增加引用计数，因此可以很好的解决上面的问题。

弱指针其实有点像 string_view，他们都只是一个视图（观察者）而已。

使用弱指针：

.expired() 可以检测弱指针是否指向无效的内存。
.lock() 锁定指向的内容，把引用计数 +1，同时返回一个 shared_ptr；如果已过期，那么会返回 nullptr（这样甚至不需要 std::optional）。

关系
#

unique_ptr 可以转化为 shared_ptr，反之不能转化。

unique_ptr 只能移动不能拷贝，shared_ptr 和 weak_ptr 可以拷贝。

shared_ptr 可以被 weak_ptr 创建一个视图。

weak_ptr 的成员函数 .lock() 有效时会返回一个 shared_ptr，否则会返回一个 nullptr。

组合、聚合和关联
#

属性 (Property)	组合 (Composition)	聚合 (Aggregation)	关联 (Association)
关系类型	整体/部分	整体/部分	其他不相关
部分可属于多个整体	否	是	是
部分的存在由整体管理	是	否	否
方向性	单向	单向	单向或双向
关系动词	是…的一部分 (Part-of)	拥有 (Has-a)	使用 (Uses-a)
**方式	类成员	引用 (数组)	引用 (数组)

初始化列表 `initializer_list`
#

如果想要让自己的类使用一个初始化列表来初始化，需要手动添加一个重载的构造函数：

template<typename T>
class MyClass{
 private:
 T m_size{};
 T* m_data{};
 public:
 MyClass(int size) : m_size{size}, m_data{new T[static_cast<size_t>(size)]}{};
 MyClass(std::initializer_list<T> list) : MyClass(static_cast<T>(list.size())){
 // 用委托构造函数来创建一个
 std::copy(list.begin(), list.end(), m_data);
 }
 // 3/5/0 法则的其他函数
}

现代 C++ 笔记：Lambda、运算符重载与闭包

Wed, 22 Oct 2025 16:29:09 +0800

命令行参数
#

早就知道在 c 中是可以在 main 中获取从命令行传入的参数的。但是对于解析是一窍不通，这里简单说一下如何获取整形。

不过，这些方法都仅仅适用于简单的字符串处理，而一个简单的带参 cli 程序，基本都要求参数能够无视顺序，可选参数，这些统统都不能实现…

`std::stringstream`
#

这个函数用于把字符串转换成流，然后再把流输出到整形。

std::stringstream convert{arcv[1]};
int num{};
if(convert>>num){
 std::cout<<num;
}

std::stoi
#

这个就是现代 C++ 的方法了。

直接转换就行：

 int num{std::stoi(argv[1])};
 std::cout << num;

lambda 表达式
#

lambda 表达式看起来像这样子：

[<capture>](<parameter list>) -> <return type> {<body>};

参数列表可以省略，返回值也可以省略，会自动推断。

所以说，最简的 lambda 表达式：[]{}。

捕获
#

对于以下变量来说，不需要捕获也可使用：

全局变量，静态局部变量，线程局部变量
常量表达式（包括被编译器视为常量表达式的变量）

捕获语法是 lambda 表达式中一个不可缺少的部分，词法分析就是通过 [] 来发现这是一个表达式的。

lambda 表达式不和 {} 一样，不能访问上级大括号中的局部变量。它只能访问静态和全局的变量，以及 constexpr。

而捕获其实就是把原来应该能让 lambda 能够使用的局部变量让它使用。

捕获的时候可以声明新变量的，在 [] 内，可以使用当前块内能访问的变量来参与运算。

捕获有两种类型：默认捕获和单个捕获。

按对象捕获
#

假设有变量 a b:

传值：[a,b]。默认传入变量的常量值，如果需要修改，需要在大括号前加上 mutable。
传引用：[&a,&b]

默认捕获
#

默认捕获会捕获 lambda 中提到的所有变量。

[=]：传入值
[&]：传入引用

不允许同时使用默认捕获和按对象的捕获。

创建闭包
#

提到闭包这个词，就不得不提函数式编程了。简单来说，函数是“一等公民”，就像我们传统的命令式编程的变量（对象）一样，可以作为参数传递，可以被返回，可以运行时创建等等。

那么闭包就是保存了当前上下文中某些状态的函数。

在 C++ 中，想实现一个闭包，还是得定义一个普通函数（虽然说跟一般的匿名函数印象不太一样）：

std::function<int(int)> multiply(int factor) {
 return [factor](int base) { return base * factor; };
}
int main() {
 auto multiply_3 = multiply(3);
 auto multiply_4 = multiply(4);
 std::cout << multiply_3(3) << '\n';
 std::cout << multiply_4(4);
}

multiply_3 和 multiply_4 就是一个闭包。

实现一个简单的函数
#

`lambda` 表达式可以作为 `lambda` 类型的变量存储。
#

 auto square{[](int base) { return base * base; }};
 std::cout << square(3);

也可以声明的时候就调用：
#

[]() { std::cout << "Hello world!\n"; }();
// 前一个括号是形参列表，后一个括号表示调用函数

值得提的一点是，这其实不是真正的函数，实际上只是重载了 () 实现像函数一样的调用。

在算法库的应用
#

前面在 <algorithm> 中，最后一个参数是比较函数的地址，其实我们可以直接在这里写 lambda 函数。

lambda 推断
#

对于实参推断（给出 (auto a, auto b) 的情况，只要函数体里面的能匹配，那么没有问题，因为编译器会自动生成重载的 lambda 表达式。

对于返回值，要求所有返回的地方一致才能推断，否则，请使用 -> 手动指定返回值类型。

带捕获的 `lambda` 拷贝
#

如果对带捕获的 lambda 表达式操作的时候，目标的类型是 std::function，那么会发生隐式类型转换，将 lambda 闭包进行深拷贝，使得多次使用 std::function 构造的多个对象出现独立的拥有原始闭包状态的副本。

在 lambda 构造的时候使用了 mutable 的值捕获，那么每次捕获的变量都是原始的捕获值。

解决方法是使用 std::ref 来包装 lambda 表达式。对于传入参数不一致的情况，它会返回一个 std::reference_wrapper 对象，保证内部存储的是对原始 lambda 对象的引用，从而保证每次调用的是同一个 lambda 表达式对象。

运算符重载
#

有三种办法重载：

友元函数：如果想要重载操作数是类对象的运算符，为了获取类内成员的访问权限，可以把此重载函数以友元的形式声明在类内。

普通函数：同时可以使用 getter 和 setter 来避免直接访问内部的成员变量。

类成员函数：仅适用于左侧操作数是类成员的情况，此时右操作数就作为参数。

一些选择建议：

重载赋值、下标 ([])、函数调用、成员选择 (->) -> 类成员函数
重载一元运算符 -> 类成员函数
不修改左操作数 -> 普通/友元函数
左操作数是内置类型无法修改 -> 普通/友元函数
左操作数可以修改 -> 类成员函数

重载函数一般返回左侧的对象的引用（以便可以连续用 . 调用）或者返回一个同类型的对象（用于连续使用重载运算符比如 +=）。

重载一元+/-
#

由于一元的 +/- 是类成员函数，而且没有参数，所以不会和二元的混淆。

重载自增/减
#

前自增/减参数列表没有参数，而后自增/减有一个 int 用于占位，从而将两者区分。

由于后自增/减要返回原来的值，所以需要一个临时变量用于返回，相比前自增/减多了开销，更倾向使用前自增/减。

下标访问重载
#

下标访问的重载返回值一般使用 auto&，从而作为左值被修改。

在 C++23 之前，如果定义类的时候使用 const，那么就需要添加一个成员重载函数：

const auto& operator[](T t) const;

这个函数被常量对象优先使用，被非常量对象次优先使用。

在 C++23，用右值引用解决此问题。

飞船运算符
#

外来语言的符号，用于比较两个数大小关系。

返回下面类型：

strong_ordering: 有equivalent、equal、greater 和 less。

weak_ordering: 比 strong 少了相等，因为是弱，只有等效。

partial_ordering: 相比 weak 多了 unordered，用于表示无法比较的情况。

从上往下可以隐式转换。

类型转换重载
#

类型转换重载也是 operator 操作符，不过重载的目标其实有点像 C 的强制转换：

class MyClass{
 //...
 public:
 operator int() {
 // conversion
 return <intType_obj>;
 }
};

无须返回值，也无须参数，因为显而易见的返回目标类型，传入的是这个类对象，这也必须是一个类成员函数。

建议加上 explicit 关键字，因为我们不希望隐式转换带来的不确定性。

如何平衡类型转换重载和转换构造函数？

假设要把 A 转换成 B：

A 可改，B 不可改。那么就定义一个类型转换的重载。

A 不可改，B 可改。那么就定义一个参数只含 A 的转换构造函数，让 B 去接收 A。

A、B 都不可改。那么定义一个普通函数实现转换吧。

复制运算符重载
#

在动态分配内存中，有时为了避免自己赋值给自己，用一个 if 来设置保护防止出现空指针问题。

在三/五/零原则中，如果不带指针，那么应该不应该定义这个复制运算符重载。（其他：析构、复制构造，移动运算符，移动构造函数）

现代 C++ 笔记：容器、迭代器与算法库

Mon, 13 Oct 2025 08:25:04 +0800

std::vector
#

此向量非彼向量。

对于字符串
#

推荐使用string_view配合 C 风格的字符串，这样效率最高，只发生一次堆内存分配。

std::vector<std::string_view> names{ "Alex", "Betty", "Caroline", "Dave","Emily","Fred","Greg","Holly" };

列表初始化器
#

std::vector vec(3)会初始化一个全 0，长度为 3 的向量；
std::vecotr vec(2,3)会初始化一个长度 2，值都为 3 的向量。
但是std::vector vec({3})会初始化一个长度 1 值为 3 的向量。

因为给出单参数的时候，会优先调用列表初始化器，这个初始化器的行为是初始化长度为参数的向量。

下标
#

当时设计让size_t是一个无符号的整数，从现在看来是一个错误，因为下标访问最容易导致环绕，最好的办法是不使用下标访问而是迭代器，次选是使用 C 风格的访问.data()。然后全部使用有符号整数。

for-each
#

推荐使用这些：

修改元素副本：auto
修改原始元素：auto
只需要查看：const auto&（大多数情况）

反向查看：使用std::view::reverse()

容量和长度
#

容量是分配给向量的内存，长度是实际使用的部分。

pop的时候长度减少容量不变；push时如果遇到容量瓶颈，会自动复制扩容（2/1.5）倍。

resize成员函数会同时改变容量和长度，reserve只改变容量。

emplace_back会显示调用构造函数，直接在堆上预留的内存构建对象，如果是是临时对象，那么要注意如果有explicit那么不能执行隐式转换。而push_back会发生一次拷贝。

在 make_unique 下，始终会产生一次拷贝，此时两者表现一致。

std::array
#

array 大部分功能都与 constexpr 兼容。

在 constexpr 表达式执行的从 unsign 到 sign 的转换是允许的，因为编译器对此信任程度很高。

.at()、[]和 std::get()
#

.at(): 运行时边界检查。(C++17 后编译时检查)
std::get<index>(arr): 编译时边界检查。
[]: 不进行边界检查，C++11 后可为 constexpr 。

对于现代 C++ 来说， .at 是更安全的选择。

因为会在越界访问的时候抛出异常。而 [] 不会进行越界检查。

用模板创建数组
#


template<typename T, size_t N>
void passByRef(const std::array<T,N>& arr){
 static_assert(N!=0);
 std::cout<<arr[N];
}

由于模板参数是编译时常量，所以可以用 static_assert ，同时，更加推荐把这两句用 std::get<N>(arr) 替代。

在 C++20，可以把 size_t 替换成 auto 。

在函数内返回 array
#

由于 array 是在栈上分配的，那么一般来说会执行返回值优化，但是移动语义就没有意义（因为不是在堆上分配的就不能仅转移指针）。如果在 C++17 之前为了避免不确定性，那用 vector ？但是怎么感觉开销在堆上更大了说…

初始化聚合数组
#

列表初始化，但是兼容 C 带来的技术债。

constexpr std::array<House, 3> houses { // 1. 初始化 std::array
 { // 2. 初始化底层 C 风格数组 (元素列表)
 { 13, 1, 7 }, // 3. 初始化第一个 House 结构体
 { 14, 2, 5 }, // 3. 初始化第二个 House 结构体
 { 15, 2, 4 } // 3. 初始化第三个 House 结构体
 }
};

此时不使用 CTAD，但是必须手动指定模板参数，或者，指定每一个元素的类型，此时可以 CTAD：

constexpr std::array houses { // 1. 初始化 std::array
 {
 Horse{ 13, 1, 7 }, // 3. 初始化第一个 House 结构体
 Horse{ 14, 2, 5 }, // 3. 初始化第二个 House 结构体
 Horse{ 15, 2, 4 } // 3. 初始化第三个 House 结构体
 }
};

reference_wrapper
#

容器中不能给模板传入 int& 但是可以传入一个 std::reference_wrapper<int> 起到同样的作用，或者直接用 std::ref() std::cref() 直接把变量转换成引用。

迭代器
#

迭代器一般使用 !=end 来判断是否到达末尾，因为不是所有迭代器都可以比较。

其本身是一个指针，指向当前的容器元素。

写的 range based for 实际上就是迭代器的语法糖。

algorithems 库
#

这是一个算法库，用于偷懒（不是

补充知识
#

二元谓词：就是接受两个参数，返回一个布尔值的函数。

在算法库中，二元谓词都需要弱序，即非自反性 (自己不能小于自己)，非对称性 (a 小于 b，那么 b 不能小于 a)，传递性。

对于 Comp 这个类型，我们假设前一个参数是 a，后一个是 b。那么有：

对 a 和 b 进行某种运算，如果希望最后算法需要保持 a 排在 b 的前面，那么就返回 true；如果算法认为 a 不应该排在 b 的前面，那么就返回 false。

最简单的办法是，假设已经按照一个顺序排列，然后取出前两个元素为 a 和 b，将他们放入表达式，如果返回 true，那么这就是你要的顺序，为 false 则是另外一个顺序。

std::sort
#

sort 有第三个参数，传入一个二元谓词，在 cppreference 中类型为 Comp ,如果是一个函数的话，只需要传地址所以不用 ()。这个函数必须严格弱序的。

std::for_each
#

foreach 可以用于方便的遍历可以迭代的容器。给定开始和结束的迭代器，和要调用的函数地址（这个函数只能传入一个参数，可用 auto ），就可以自动迭代。

同时和 std::next 配合使用，可以跳过一部分迭代器，获得很高的灵活性。这时候就有了比基于范围的 for 循环更加灵活。

ranges (C++20)
#

从 C++20 开始，很多算法添加了对应的重载，直接传入容器的地址就可以实现操作，即 std::ranges::for_each(arr)。

函数指针
#

C 的函数指针如果不用 typedef将会非常复杂，而 C++ 提供了一个模板，以一个传入 int, int 返回 int 的函数指针为例：

#include<functional>
std::function<int(int, int)> ptr {&foo};
std::function<int(int, int)> bar(){
 // some implementation
}

搭建基于 VSCode 的跨平台 C++ 学习环境

Sat, 04 Oct 2025 16:45:12 +0800

前言
#

早期学习 C/C++ 是非常痛苦的，不仅被老师要求下载 20G 的宇宙 IDE VS，还得自己格式化代码，这就是我一开始对此不感冒的原因。

但是随着学的东西多了，不写代码也不行啊，我才渐渐发现有那么多强大的工具我不知道。

所以这里记录一下自己的折腾过程，希望能帮到初学 C++ 的朋友们。

准备
#

由于我主要是在 ArchLinux 上面学习，偶尔会在 Windows 上面测试，这里大部分内容都会在 Linux 上面完成，不过别担心，这些工具都是跨平台的。

Linux
#

很简单，直接安装这些软件包：

Clang LLVM 的前端，包括了 Clangd 即语言服务器
GCC/LLVM 编译器
CMake 依赖管理/构建系统
Ninja 构建器

Windows
#

推荐用scoop一键解决，对于这些命令行工具可以说非常方便了。

需要安装的包：

llvm-mingw 包含了 clangd/clang 了
CMake
Ninja

如果想GCC的话，可以到WinLibs下载：

一般来说下UCRT就行了，从win10之后都支持UCRT的。

安装 VSCode 不用多说了吧？

安装这些拓展：

CMake Tools
Clangd
CodeLLDB

CMake 拓展设置
#

按照如图显示的配置CMake生成的数据库文件，以便后续的Clangd查找。

Clangd 拓展设置
#

填入Clangd寻找数据库的位置

CodeLLDB 拓展设置
#

安装完可能会下载一个调试包，对网络环境要求较高，如果遇到问题可以参考这篇文章。

创建项目
#

配置 CMake
#

在你的项目根文件夹建立一个主CMakeLists.txt,内容可以这么写：

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# 最低 CMake 版本要求
cmake_minimum_required(VERSION 3.31)

# 项目名称和语言
project(learnproj VERSION 1.0 LANGUAGES CXX)

# 设置 C++ 标准
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)


file(GLOB SUB_PROJECT_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/src/*)

# 遍历所有找到的目录
foreach(SUB_DIR ${SUB_PROJECT_DIRS})
 # 检查该目录下是否存在 CMakeLists.txt 文件
 if(IS_DIRECTORY ${SUB_DIR} AND EXISTS "${SUB_DIR}/CMakeLists.txt")
 # 将该目录名打印出来，方便调试
 get_filename_component(PROJECT_NAME ${SUB_DIR} NAME)
 message(STATUS "Found and added subproject: ${PROJECT_NAME}")

 # 将这个文件夹作为一个子项目添加进来
 add_subdirectory(${SUB_DIR})
 endif()
endforeach()


## 根据需要按需添加

# # 查找 Qt 库
# find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)

# 添加可执行文件

# # 链接 Qt 库
# target_link_libraries(MyQtProject PRIVATE Qt6::Core Qt6::Gui Qt6::Widgets)

# # 自动处理 MOC、UIC 和 RCC
# set_target_properties(MyQtProject PROPERTIES
# AUTOMOC ON
# AUTOUIC ON
# AUTORCC ON
# )

你可以根据自己的需要，设置 C++ 标准，扫描的文件夹，链接的库。这里就以src目录放置源文件，include放置头文件为例。

进入src/current创建一个子CMakeLists.txt，内容写上：

get_filename_component(PROJECT_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)

## 如果你需要添加别的源文件，别忘了在这里添加文件名，空白符为分隔。
add_executable(${PROJECT_NAME} main.cpp
 )

if(MSVC)
 target_compile_options(${PROJECT_NAME} PRIVATE /W4 /WX)
else()
 ## 非MSVC指定一些警告参数
 target_compile_options(${PROJECT_NAME} PRIVATE
 -Wall
 -Wextra
 -Wpedantic
 # -Werror
 -Wconversion
 )
endif()

## 这里指定的头文件的路径

target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../include/${PROJECT_NAME})

创建一个main.cpp，内容可以为空，你的项目应该这样：

接着我们给CMake生成一些预设。

快速入门 - 添加新预设 - 从编译器创建

你如果只装了Clang，那么用不带cl的就行，同样也可以用GCC，看个人喜好。

输入名字，这里我是用平台-编译器-构建器-版本来命名的，回车会自动生成一个CMakePresets.json，像这样：

因为我比较喜欢Ninja，所以加入这一行。如果你想用Make，那么记得手动安装。

然后在这里添加新生成预设，从配置预设中构建，名字可以是构建预设后面加上-build。

然后在这里选一下就好了：

下面的生成目标可以选择你的文件夹名称了：

打开你的main.cpp，看看clangd怎么样？原来已经成功加载数据库并运行了：

随便写点东西，然后点击左下角的生成，启动，你的代码应该可以运行了。

配置 task
#

有人说，哎，我的F5一键调试呢？

在.vscode/下创建一个launch.json，写上：

{
 "version": "0.2.0",
 "configurations": [

 {
 "type": "lldb",
 "request": "launch",
 "name": "Debug",
 "program": "${command:cmake.launchTargetPath}",
 "args": [],
 "console": "integratedTerminal",
 "cwd": "${workspaceFolder}",
 },

 ]
}

大功告成！

后续
#

格式化
#

你可能对于Clangd的格式化不太满意，那么可以在项目根目录创建一个.clang-format的文件，里面写上你想要的风格，具体可以去搜一下。

这是我的：

# .clang-format
# 使用 LLVM 风格作为基础，这是很常见的风格
BasedOnStyle: LLVM
# 强制缩进宽度为 4 个空格
IndentWidth: 4
# 强制指针和引用靠左
PointerAlignment: Left
# 强制使用空格进行缩进，而不是制表符
UseTab: Never

其他
#

如果想添加头文件，直接往include/<你的项目名字>放置即可。

如果觉得项目不错，想保留代码，直接把current文件夹复制一份，改个名，运行的时候到CMake里面切换配置/生成目标就好。

如果你想用MSVC，那么可以下VS Installer，里面只选构建工具，不过注意这样是没法生成compile_commands.json给Clangd读取的。

现代 C++ 笔记：类、构造函数与成员初始化

Mon, 29 Sep 2025 08:25:14 +0800

枚举
#

枚举实现了内容与整形相关联的数据结构，是隐式的编译时常量。

枚举类型，枚举符和枚举变量。

枚举符会放入当前命名空间和其本身的命名空间中，如果是全局的枚举 (unscoped),那么可以直接使用。

对枚举变量空初始化会使得枚举符是 0，所以推荐把第一个枚举符设置成未知/无效。

枚举类用enum class Name{};定义，只能在其本身的作用域使用，无法被隐式转换成整数，在安全性上更优。

可以在需要的使用using enum Name;来简化使用 (C++20)。

结构体
#

对其中某些参数进行初始化：

struct Worker {
 int id{};
 int age{};
 double wage{};
};

Worker John { .id{1},.wage{5000}}; //部分列表初始化，age 初始化为 0，clangd 有 bug 会警告

Worker John { .id{1},John.age, .wage{5000}}; //这样可以占位，一样使得 age 初始化为 0

结构体模板
#

结构体当然也可以传入模板参数，不过在 C++20 更加完善，如果使用 C++17，可能需要手动指定推断：

template <typename T>
struct Pair
{
 T first{};
 T second{};
};

// Here's a deduction guide for our Pair (needed in C++17 only)
// Pair objects initialized with arguments of type T and T should deduce to Pair<T>
template <typename T>
Pair(T, T) -> Pair<T>;

int main()
{
 Pair<int> p1{ 1, 2 }; // explicitly specify class template Pair<int> (C++11 onward)
 Pair p2{ 1, 2 }; // CTAD used to deduce Pair<int> from the initializers (C++17)

 return 0;
}

可以为类型模板起别名：

template <typename T>
using Coord = Pair<T>; // Coord is an alias for Pair<T>

类
#

类的成员变量，成员函数是隐式内联的，所以放在头文件中被多个源文件引用的时候，不违反 ODR 原则。

在类中，不强制声明语句位于使用之前，只要他们都在同一个类中即可。

调用常量类对象内部的函数，要将此成员函数声明为const。

void foo() const {
 //...
}

struct和class仅有的差异：struct默认使用public:，而class默认使用private:。在继承性上也是这样。

protect:允许派生的类访问，其可见性介于两者之间。

成员初始化列表
#

现代 C++ 使用成员初始化列表，而不是直接初始化列表。具体是：

class Foo{
 int m_a{};
 int m_b{};

 Foo(int a, int b) : m_a{a}, m_b{b} {
 //other...
 }
}

以前 (C++03) 之前则是用的()直接初始化。

成员初始化的顺序和成员初始化列表无关，只跟泪中定义成员变量的顺序有关。

`std::string_view`特殊处理
#

一个例子：

#include <iostream>
#include <string>
#include <string_view>

class Ball
{
private:
 std::string m_color { "none" };
 double m_radius { 0.0 };

public:
 Ball(std::string_view color, double radius)
 : m_color { color }
 , m_radius { radius }
 {
 }

 const std::string& getColor() const { return m_color; }
 double getRadius() const { return m_radius; }
};

void print(const Ball& ball)
{
 std::cout << "Ball(" << ball.getColor() << ", " << ball.getRadius() << ")\n";
}

int main()
{
 Ball blue { "blue", 10.0 };
 print(blue);

 Ball red { "red", 12.0 };
 print(red);

 return 0;
}

为什么这里构造函数需要用string_view作为参数？不能用const string&来替换？

string_view提供了灵活性，如果选择后者，那么如果传入一个 C 语言的字面量字符串的时候，就必须在堆上构建临时的string对象，而这对性能开销很大；对于前者，永远不会构造临时对象，而是只有一个指针，在真正初始化的时候完成一次复制。(甚至后面还能用移动语义)

为什么getter不能像上面一样反过来？

因为在类内部的存储对象就是真正的string，给出它的引用使得外部访问的类型明确，不会造成歧义；同时也提示这个引用的生命周期是明确的————跟成员变量一致。

构造函数
#

构造函数用于初始化类，在此我们可以手动指定成员变量如何初始化。

转化构造函数
#

转化构造函数其实就是特殊的构造函数，其只拥有一个参数。如果传入一个该参数类型的变量，那么就会自动把这这个变量转化成类。

默认构造函数
#

class Foo{
 int m_a;
 int m_b{};

 public:
 Foo () = default; //可以显式的声明构造函数为默认构造函数，此时 m_a 会被默认初始化为 0。
 Foo () {} //用户自己初始化，但是空初始化，此时 m_a 不会被初始化，是垃圾值。
}

委托构造函数
#

在一个构造函数的:后面写上参数更多的重载构造函数，可以用另一个构造函数来初始化，但是此构造函数就不能再初始化成员变量。

尽量不要使用太多的构造函数。

复制构造函数
#

复制构造函数的参数必须是引用，要不然就会发生无限递归的调用复制函数。

复制构造函数不应用于复制以外的意图，因为编译器可能会发生复制省略 (copy elision)

explicit 关键字
#

禁止隐式转换：从单个参数隐式转换成类对象；从列表{xxx,xxx}转换成类对象。

在具有单个参数的构造函数前加入，避免编译器执行隐式转换。

由于 C++ 对于用户定义的转换，只允许转换一次，所以下面的代码会报错：

#include <iostream>
#include <string>
#include <string_view>

class Employee
{
private:
 std::string m_name{};

public:
 Employee(std::string_view name)
 : m_name{ name }
 {
 }

 const std::string& getName() const { return m_name; }
};

void printEmployee(Employee e) // has an Employee parameter
{
 std::cout << e.getName();
}

int main()
{
 // 此时要经历两次转换：C-Style string -> string_view -> class Employee
 printEmployee("Joe"); // compile error

 // 修正：
 // 方法 1:
 // using std::literals;
 // printEmployee("Joe"sv);
 // 方法 2:
 // printEmployee(Employee{"Joe"});


 return 0;
}

不对复制/移动构造函数使用explicit，因为他们不执行隐式转换。

如果转换的时候两者等效且零开销，可以不使用explicit。

比如：

const char* -> string_view
string -> string_view

constexpr 问题
#

从 C++14 开始，constexpr修饰函数仅仅是作为编译时求值的提示，如果传入的变量不是一个constexpr，那么这个函数就具有运行时的上下文，constexpr修饰就不起作用。

对于struct，其作为一个聚合体，默认的构造函数无须加入constexpr就可以用它初始化一个类对象。但是对于class，就必须public，同时手动指定构造函数是constexpr，比如：

Foo {
 public:
 constexpr Foo = default;
}

而constexpr修饰一个类对象的时候，如果涉及到的函数（构造函数、setter以及使用到的成员函数）都有constexpr修饰，表示这个类具有编译时的上下文，会让此对象成为一个编译时常量。在编译时如果此对象是用临时对象初始化的，对临时对象是可以修改的，但是一旦这个对象初始化完毕，那么就不再可以修改。

后续要访问此constexpr对象，那么所有的函数()后，都必须有const，保证不修改此对象。

参考 (learncpp - 14.17)[https://www.learncpp.com/cpp-tutorial/constexpr-aggregates-and-classes/]

this 指针
#

this指针是一个const指针（顶层），指向当前操作的类。

this指针出现比引用早，不然它多少是个引用。

成员函数类外定义
#

成员函数可以在类外定义，要加上域访问解析符::。如果是类的正下方（.h中），前面加inline关键字以防止重复包含；如果是对应的 cpp 中，无须加inline。

默认参数在声明时给出。

类型模板参数
#

可以在类指定类型模板参数，不过如果成员函数先声明，然后在类外定义，那么需要单独再指定一次模板参数。

模板类外的成员函数要紧挨着类定义的下面。

注意：

所有的模板函数都是默认内联的，所以就算在类外定义，已经隐式inline了。
类外定义的函数的类型模板参数必须与类的一致。

传入类模板的参数，无须加<T>，因为已经在Pair<T>::作用域中了。

template <typename T>
bool Pair<T>::isEqual(const Pair& pair) // note the parameter has type Pair, not Pair<T>
{
 return m_first == pair.m_first && m_second == pair.m_second;
}

静态成员变量
#

静态成员变量在所有实例化的对象都可用，具有相同的值，在未实例化的时候也可以使用，直接用类名和域访问解析符访问。

声明的时候，在类内加static关键字，类外定义不能加关键字。

位置：直接在类后面/类对应的cpp，头文件中可以加inline。

只有静态成员变量可以自动推断，普通的不允许。

用途：一个根据数量递增的 ID

静态成员函数
#

静态成员函数用于访问静态全局变量。

有替代品：

命名空间：没有访问控制
静态全局类对象

友元
#

在被访问的类中声明，从而使得外部的类/函数能够访问private和protected的对象。

友元函数
#

在类中声明，自动成为非成员的函数，类外定义。

此项特性对于运算符重载非常有用。

友元类
#

直接在类内定义。

现代 C++ 笔记：引用、右值与函数模板

Thu, 25 Sep 2025 16:18:15 +0800

函数默认参数
#

声明的时候带默认参数，定义的时候可以不带。但是不能定义的时候有默认参数而声明的时候没有。
如果用默认参数，那么必须从右到左都有（左边可以没有，不能中断）。
传入参数的时候，只能从左往右传入，未传入的自动使用默认的参数。

模板
#

定义：

template<typename T> T foo(T a) {
 //your function
}

如果还有一个同名的非模板函数：

int foo(int a) {
 // function
}

调用的时候：

如果使用foo()，那么会直接调用非模板的函数。
如果用foo<>()，那么会自动推断，并从模板实例化函数。如果指定类型，则直接从模板按指定的类型实例化函数。

在两个不同的模板参数时，可以定义模板返回用auto关键字，让编译器自动推导返回类型。这是 C++17 后的 CTAD(class template auto deduction)。

注意： CTAD 仅用于推断实参 (argument，调用时) 不能推断形参 (parameter，函数声明)

在 C++20 后，函数参数传入auto会自动变成模板。

非类型模板：定义constexpr或者consteval（C++20）,不写 typename 。

template <int N>
auto foo() {
 std::cout<<N;
}

foo<5>(); // print 5

由于模板展开需要看到定义，所以模板函数应该放在头中。模板不违反单一定义原则。

左值和右值
#

左值表达式：在表达式结束之后，还能用标识对象访问的表达式。
右值表达式：表达式结束之后立即销毁的临时量。

特别：++x是左值，x++是右值。

引用
#

左值引用
#

左值引用只能绑定到可修改的左值。

常量左值引用可以绑定到可修改/不可修改的左值，右值。

一个常量引用可以引用非常量的对应对象，这使得此引用由编译器保证不修改其引用的对象，而且是函数的只读参数的推荐做法。

如果类型不匹配，引用会尝试将其进行隐式类型转换，得到一个临时对象。需要注意：

只允许数值提升和非窄化转换。
此时转化后的临时对象会被引用持有，生命周期与引用本身相同。
修改原始对象不会对因引用产生的临时对象造成影响。

小心！引用无法延长函数返回值的声明周期，以下例子为 UB：

const int& a = getTempVar();

引用和指针
#

左值引用可以绑定到右值，但是必须是常量的引用才可以。同时，对于右值的常量引用会使得直接绑定的临时对象生命周期被延长。

而右值引用 (&&) 则是用于移动语义。

与 auto 相结合
#

顶级const: 指的是修饰此别名/对象的const
低级const: 指的是被引用绑定/被指针指向的const

指针可以同时拥有两种const，但是引用不行，因为引用不是对象。

当用auto关键字以及引用来初始化对象时，遵守：

引用会被删除。
顶层的常量会被删除。

当然可以用auto&来重新添加引用，不过这样会同时保留顶级的const。我们一般推荐要手动加上const，这样会让语义更加清晰。

constexpr不是表达式的一部分，所以auto不会自动推断出它，如果需要则要在 auto 前面手动加上，就像这样：

constexpr const auto& ref{getConstRef()};

但是推断指针的时候，auto会完整的保留指针的类型。

有一点比较特殊，使用const auto和auto const是同义的，都会使得新对象成为一个常量的指针。但是如果你想const auto const，那就会报错。

如果想要这么做，最好明确一点，就像这样：

const auto*
auto* const
const auto* const

这样就很明显的看出，在*左边的意义是指向常量，在右边的意义是常量的指针，事实上既然都auto了，也不差这几个关键字吧？我其实比较担心auto不够智能这个问题。

为什么呢？

因为指针是一个对象，而引用可以理解成一个别名，所以当我们对引用进行推断的时候，实际上是推断原始的对象究竟是什么类型。

in/out 参数
#

为了避免拷贝，可以预先初始化一个对象传入其引用，这样可以避免拷贝，不过使得参数列表很乱。如果可行，还是通过返回值优化或者移动语义。

RouterOS 的 IPv6 多网段统一进行 NAPT 转换

Tue, 23 Sep 2025 21:05:32 +0800

前言
#

终于决定给社团的网络修一修了~

实践
#

内网划分
#

对于内网的划分是这样的：

使用ULA子网：fd11:4514:5a51::/48

然后划分四个网段，分别给设施、1-3 楼用户。

fd11:4514:5a51:0::/64，尽量使用EUI64分配地址，同时分配公网前缀用于IPv6访问。
fd11:4514:5a51:[1-3]::/64，仅仅分配ULA，不分配公网前缀，使得设备流量分流到三条移动宽带。

/DNPT 规则
#

相比之前使用的fc00-fc03网段来说，可以少写很多规则，直接转换/60的前缀即可。

参考如下：

 3 ;;; PCC-1 Output
 chain=prerouting action=mark-packet new-packet-mark=PCC-1 passthrough=yes src-address=fd11:4514:5a51::/60 dst-address-list=!ULAs per-connection-classifier=src-address:3/0 log=no log-prefix=""

 4 ;;; PCC-2 Output
 chain=prerouting action=mark-packet new-packet-mark=PCC-2 passthrough=yes src-address=fd11:4514:5a51::/60 dst-address-list=!ULAs per-connection-classifier=src-address:3/1 log=no log-prefix=""

 5 ;;; PCC-3 Output
 chain=prerouting action=mark-packet new-packet-mark=PCC-3 passthrough=yes src-address=fd11:4514:5a51::/60 dst-address-list=!ULAs per-connection-classifier=src-address:3/2 log=no log-prefix=""

 6 ;;; PCC-1 Output NPT
 chain=postrouting action=SNPT src-prefix=fd11:4514:5a51::/60 dst-prefix=2409:8a20:ae0:6af0::/60 src-address=fd11:4514:5a51::/60 packet-mark=PCC-1 log=no log-prefix=""

 7 ;;; PCC-2 Output NPT
 chain=postrouting action=SNPT src-prefix=fd11:4514:5a51::/60 dst-prefix=2409:8a20:ae0:1360::/60 src-address=fd11:4514:5a51::/60 packet-mark=PCC-2 log=no log-prefix=""

 8 ;;; PCC-3 Output NPT
 chain=postrouting action=SNPT src-prefix=fd11:4514:5a51::/60 dst-prefix=2409:8a20:bc5:c950::/60 src-address=fd11:4514:5a51::/60 packet-mark=PCC-3 log=no log-prefix=""

9 ;;; PCC-1 Input NPT
 chain=prerouting action=dnpt src-prefix=2409:8a20:ae0:6af0::/60 dst-prefix=fd11:4514:5a51::/60 dst-address=2409:8a20:ae0:6af0::/60 log=no log-prefix=""

10 ;;; PCC-2 Input NPT
 chain=prerouting action=dnpt src-prefix=2409:8a20:ae0:1360::/60 dst-prefix=fd11:4514:5a51::/60 dst-address=2409:8a20:ae0:1360::/60 log=no log-prefix=""

11 ;;; PCC-3 Input NPT
 chain=prerouting action=dnpt src-prefix=2409:8a20:bc5:c950::/60 dst-prefix=fd11:4514:5a51::/60 dst-address=2409:8a20:bc5:c950::/60 log=no log-prefix=""

总共 9 条规则就可以解决，依次是出站 PCC 规则分流，出站规则，入站 DNPT 规则。

问题
#

脚本自动更新问题
#

我真的非常不愿意去看 RouterOS 的脚本，太乱了，沿用了之前的内容，只是修改了其中的网段。

入站问题
#

按照现有的规则，实际上是无法入站的，需要单独添加一条规则，而且似乎只对EUI64的地址生效。

 2 ;;; PCC-1 LAN_Device
chain=prerouting action=accept dst-address=2409:8a20:ae0:6af0::/64 log=no log-prefix=""

其实，对于隐私地址，防火墙也非常难以匹配规则，因为后缀变，运营商的前缀也跟着变，一般解决方案都是socat或者反向匹配 (目标地址写::be24:11ff:fe82:8282/::ffff:ffff:ffff:ffff这样)。

内网访问问题
#

对于内网 v6 互访 (从 0 网段到 1) 是失败的，我怀疑是 PCC 规则误伤了，但是排查还是挺困难的，因为 RouterOS 的日志调试我根本不会用，不出日志，你说要是有个tcpdump我就会了…

补充
#

关于 EUI64 和 RFC4291
#

使用NAPT，对于EUI64:

2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
 link/ether 00:0c:29:65:43:21 brd ff:ff:ff:ff:ff:ff
 altname enp11s0
 inet 192.168.114.39/24 brd 192.168.114.255 scope global dynamic ens192
 valid_lft 13117sec preferred_lft 13117sec
 inet6 fd11:4514:5a51:0:20c:29ff:fe65:4321/64 scope global dynamic mngtmpaddr
 valid_lft 6993sec preferred_lft 3393sec
 inet6 2409:8a20:ae0:6af0:20c:29ff:fe65:4321/64 scope global dynamic mngtmpaddr
 valid_lft 7124sec preferred_lft 3524sec

开启了隐私拓展后：

4: enp0s20f0u3u4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
 link/ether 01:e0:22:65:43:21 brd ff:ff:ff:ff:ff:ff
 altname enx00e04c6809ce
 inet 192.168.101.80/24 brd 192.168.101.255 scope global dynamic noprefixroute enp0s20f0u3u4
 valid_lft 8484sec preferred_lft 8484sec
 inet6 fd11:4514:5a51:1:ff9d:d0eb:c4f3:ad54/64 scope global dynamic noprefixroute
 valid_lft 7117sec preferred_lft 3517sec
❯ curl 6.ipw.cn
2409:8a20:ae0:1361:cfab:d0eb:c4f3:ad543

其中 65-80 的这一段，若不是真实反应 MAC 地址，那么好像在SNPT的时候不会为你保留。

有人说，变化是因为要符合校验和，但是对于EUI64地址好像并不需要啊，这是为什么呢？

查了下，发现EUI64并没有强制要求必须保留，所以为了效率和随机性，就找了一个能够唯一标识的地址使用了。

总结
#

感觉调 RouterOS 完全就是在猜啊，没有 wrt 类那种我理解的感觉，希望以后能找到个大佬浇浇我。

现代 C++ 笔记：类型转换、auto 与标准 I/O

Tue, 23 Sep 2025 08:50:10 +0800

循环，条件与分支
#

这个东西老生常谈了，我本来没有看的欲望，但是有一道题目很有意思，在此记录：

从 1 开始，向上计数，将任何只能被 3 整除的数字替换为“fizz”一词，将任何只能被 5 整除的数字替换为“buzz”一词，将任何可被 3 和 5 整除的数字替换为“fizzbuzz”一词，如果还可被 7 整除，那么替换为“fizzbuzzpop”。

首先，介绍一个名词：分支预测。

简单来说，现代 CPU 在进行多分支的判断（if-else）的时候，其实会去猜程序下一步的路径，如果猜对了，那么效率会提升；如果猜错了，那么只能把流水线上面的内容清空，然后重新执行指令。

所以无论如何，应该尽量避免写if-else。

题目给出的答案是这么写的：

// h/t to reader Waldo for suggesting this quiz
#include <iostream>

void fizzbuzz(int count) {
 for (int i{1}; i <= count; ++i) {
 bool printed{false};
 if (i % 3 == 0) {
 std::cout << "fizz";
 printed = true;
 }
 if (i % 5 == 0) {
 std::cout << "buzz";
 printed = true;
 }
 if (i % 7 == 0) {
 std::cout << "pop";
 printed = true;
 }

 if (!printed)
 std::cout << i;

 std::cout << '\n';
 } // end for loop
}

int main() {
 fizzbuzz(150);

 return 0;
}

能运行吗？能，优雅吗？我不太满意。

所以说，有没有一个办法，不同于这个思路，同时又能更计算机一点？

评论区的思路：

#include <iostream>

void fizzbuzz(int n)
{
 for (int i{ 1 }; i <= n; i++)
 {
 int f = (i%7 == 0)*4 + (i%5 == 0)*2 + (i%3 == 0);
 switch (f)
 {
 case 0:
 std::cout << i;
 break;
 case 1:
 std::cout << "fizz";
 break;
 case 2:
 std::cout << "buzz";
 break;
 case 3:
 std::cout << "fizzbuzz";
 break;
 case 4:
 std::cout << "pop";
 break;
 case 5:
 std::cout << "fizzpop";
 break;
 case 6:
 std::cout << "buzzpop";
 break;
 case 7:
 std::cout << "fizzbuzzpop";
 break;
 }
 std::cout << '\n';
 }
 return;
}

int main()
{
 fizzbuzz(22);
}

这个方法非常巧妙，把每一个分支映射到了一个二进制的向量空间上面，这将会极大的提高性能，因为对于 CPU 来说，移位操作是原生的。但是，带来的就是更多相似字符串的重复占用，不知道这是不是良好的实践呢？

如果还想减少的话，还是用if来去测试位，不过这样又引入了分支。

其实这么用的地方还是很多的，POSIX 的权限就是个例子。但是，用的时候就是想不到啊！

标准输出，标准错误和标准输入
#

这三者是这样的：

名字	文件描述符	在 c++ 中的对应
标准输入	0	`std::cin`
标准输出	1	`std::cout`
标准错误	2	`std::cerr`

类型转换
#

数值提升 (numberic promotion):
#

同类型，把一个更短的类型转换成一个更长的类型，安全，不会造成精度丢失。

只有两条路径：

bool，有/无负号的短整形，字符型->int->unsigned int
float->double

注意，从int到long不是提升，是转换。

数值转换 (numberic conversion):
#

基本类型的转换，包括：

窄化 (narrowing conversion)：长的类型转化成一个更短的类型，在{}中不被允许。

但是constexpr是允许的，因为是编译时求值，所以实际上是截断不是转化。

算术转换 (arithmetic conversion):
#

对基本算术操作符两端的不同类型进行转换，有些规则：

整数转浮点。
对于无符号/有符号：

如果没超过有符号上限，那就转换成有符号。
超过了，那就转换成无符号。

static_cast在编译时检查（类型在编译时是确定的），dynamic_cast在运行时检查。

不建议使用 C-Style 的转换，因为他可能使用上面中的任意一个以及const_cast。

auto
#

对于auto来说，必须要先确定得到的结果是什么，才能做推断，不能对没有初始化值的变量做推断。

在用std::cin的时候，给的类型是istream，所以自动推断会推出这个类型，肯定不是你想要的结果。

auto不会保留const的修饰，所以如果需要保留，用const auto。

auto 的尾随返回值
#

这其实一点都不auto，只是为了让函数名对齐，然后用->给出返回类型罢了。

auto add(int x, int y) -> int;
auto divide(double x, double y) -> double;
auto printSomething() -> void;
auto generateSubstring(const std::string &s, int start, int len) -> std::string;

现代 C++ 笔记：string_view、static 与内部链接

Fri, 19 Sep 2025 19:13:57 +0800

符号变量
#

magic number 这个词，我一直认为是大家约定好了的一组数，但是这里是不同的含义。

它指的是直接放在函数里面，没有任何交代的数据，使得程序更加难读。

所以做法一般是推荐用const修饰，如果标准高的话，constexpr，请。

字符串
#

从 c 开始那么久，都一直没认真了解过字符串，这会终于明白了std::string的一些基本操作。

众所周知，字符串里面不可避免包含空白字符，那么办法就是通过std::getline()，但是如果在std::cin之后使用，大概率这么传入(std::cin, target)是无效的，因为cin在读到空白字符之后会停止，并且把空白字符留在缓冲区，那么下一次读取的时候，直接就把一个\n传入了，所以你的字符串啥都没有。

问题解决是通过流操纵符std::ws（这个需要每次 cin 的时候都提供），控制如果一开始就读取到空白字符，那么就忽略掉这个字符继续读取后面的东西。

这时就很好的解决了读取到\n的问题，除非读取到下一个\n，那么getline才停止读取，此时字符串也成功存入了这一行。

怎么说呢，感觉比 c 先进一点点（？

string
#

因为string本身就是一个类，其构造函数本身就是重载的，所以无论在初始化的时候传入string,C-Style string还是string_view，都不会发生隐式转换。

但是如果函数要求的只是一个string参数，那么把别的类型传入，就会发生编译错误。原因是不允许发生string_view到string的窄化转换，性能问题。

string_view
#

// 用 string_view 指向 string 的话，不产生多余的拷贝，只是在初始化的时候拷贝进入 string
std::string name {"John"}; //此处产生拷贝
std::string_view name_v {name}; // 不拷贝

// 实际上，是让 string_view 指向一个 c 风格的字符串，这个过程没有拷贝。
std::string_view name {"John"};

如果常量能够在编译时确定，那么就可以应用constexpr。很显然，前者是不可行的，后者可以。

⚠️ string_view 的行为与普通的引用和指针不一致。

当用string来初始化string_view，然后string被修改之后，string_view并不会更新string的新长度。

如果要避免，得更新视图。（不知道智能指针是否有帮助？）

不建议用string_view来返回，除非它是用 C 式的字符串初始化的。

对于用string_view来说，推荐用法：

std::string_view s{"aaa"sv}; //在堆上分配了 C-Style 字符串，但是用的构造函数不一致，在复制省略中，这是一种过编译的办法。

实现零成本抽象，原因嘛，以后再补充…

对于流程控制的一些建议
#

对于只有两个分支的if，可以考虑用三元运算符? :。

如果表达式本身只有为0/1两种可能，那么就无须写==，直接把表达式扔上去即可。

static 与内部链接
#

在变量前加入static关键字，不仅仅会使变量在整个程序的生命周期有效，还会使得无法被外部文件访问此变量。

现代 cpp 已经不推荐使用此关键字了。转而替代的是匿名命名空间，后者可以实现里面的变量直接在当前文件访问，其他文件不可访问。

没加static的变量默认是全局变量，在别的文件使用extern引入，const默认就是内部变量。

static 的最佳用法

static最适合用于函数内的计数场景，比如调用了函数几次，只需在函数内声明一个静态局部变量即可。

不推荐使用此方法实现相同的输入不同的输出内容，这其实也不符合 fp 的原则。如果必须要这么用，那么最好的办法是将条件一起传入。参考

inline 关键字
#

从 cpp17 开始，完善了inline，使得constexpr对于编译时常量跨文件有了最佳解决方案。

inline本义其实指的是把函数展开到调用的地方，但是修饰constexpr时，它被赋予了不同的意义。

inline修饰constexpr特殊，当在多个文件中定义的时候，会告诉链接器从任意一份中取出一份定义，并且在所有文件中共享，同时并不违反 ODR 原则，这使得把inline放在文件头里面，就可以向引入这个头文件的所有源文件进行分发。

inline同时还可以修饰命名空间，修饰非匿名的命名空间可以使得本来需要域解析操作符的使用，直接被透传到全局的命名空间中去。

下面是一个嵌套的命名空间的例子，使得接口能够安全的对当前文件中的其他函数暴露：

#include <iostream>

namespace V1 // declare a normal namespace named V1
{
 void doSomething()
 {
 std::cout << "V1\n";
 }
}

inline namespace V2 // declare an inline namespace named V2
{
 namespace // unnamed namespace
 {
 void doSomething() // has internal linkage
 {
 std::cout << "V2\n";
 }

 }
}

int main()
{
 V1::doSomething(); // calls the V1 version of doSomething()
 V2::doSomething(); // calls the V2 version of doSomething()

 doSomething(); // calls the inline version of doSomething() (which is V2)

 return 0;
}

inline作用于V2命名空间，使得内部内容能够无须域解析操作符，但是匿名命名空间保护性最强，使得内部内容只能有当前文件访问，无法暴露给外部文件。

In modern C++, the term inline has evolved to mean “multiple definitions are allowed”.

总结下，inline除了内联的意义，其实还有：

对于变量：在头文件中定义，使得此头被多次引入的时候只使用共享的一次，避免每次都加载到文件，在头文件被多次引用的时候很有用 (c++17)。同时，如果变量同时被static constexpr修饰，那么它是隐式inline的。
对于函数：在头文件中定义的函数需要加（但是不推荐，等到后面看到类的构造函数再会来补充），声明的函数无须加。
对于命名空间：把某个命名空间中的内容暴露到全局的命名空间，使得其中内容访问无须加域解析操作符。

using 语句和 using 声明
#

语句指的是用一个命名空间，这个一般范围过大，不推荐，此处狠狠批评那些教用using namespace std;的人。

using 声明是可以接受的，因为它比起别名更加清晰，而不是只让写代码的人看懂。

现代 C++ 笔记：初始化、字面量与编译期

Thu, 11 Sep 2025 08:10:38 +0800

前言
#

最近找到个个还不错的网站，适合我这种大白，遂开始学习，记录一些感受。

此系列可能没有很好的排版，因为是给自己看的。

不保证所有的内容一定正确，因为是学习过程中记录的，所以可能还会有完全不正确的理解。

澄清一个我混淆的概念
#

表达式：求值，调用函数，变量/常量和运算符相结合的东西

语句：有分号的东西，可以由多个表达式复合而成。

statement expression（原谅我不会翻译）：只含一个表达式的语句。

标识符：用户自定义的名称，不以数字开头。

关键字：系统保留字，用于流程控制。

cin/cout探秘
#

我一直好奇，<<是怎么实现的，还能同时接着，是怎么使用的。

事实上，这运用的是运算符重载，语义分析会处理左右两边的表达式，然后决定是否重载它。

<<是左结合的，所以优先处理左边的部分。<<一看到左边是一个ostream类型，右边是一个字符串，自动重载，通过运算返回一个ostream，接着再处理次级优先的，依次拼接一个完整的字符串流。

这里提到一个重要概念：副作用。

正常来说，一个函数应该要返回值。当我们只使用一个<<的时候，确实只用到了副作用，如果我们连在一起使用的时候，那么返回值就非常重要了。这是不是有点像 fp，给定输入得到输出，接着成为另一个输入？

现代的初始化
#

现在 c++ 推荐使用列表直接初始化，避免隐式类型转换。

如：foo{}

还有别的办法：

直接初始化：foo(1)
间接列表初始化：foo = {1}

⚠️不推荐在同一行定义多个变量，因为会在 git 中导致 diff 不清晰。

literal/variable
#

学过微机的人都知道，一个程序加载进内存，会分别放到代码段和数据段，接着获取到一些段（stack，pile）。

其中：

代码段是只读的，同时和堆栈段中间还相隔了一些部分，这是避免数据溢出破坏程序的运行。
对于字面量来说，使用它，就直接到数据段里面取，没有分配给他额外的空间。
而对于变量来说，使用它，先得从数据段中拷贝一份到栈/堆（假设初始化的话），接着读取这个地址指向的内容，才能进行访问。

compile-time / runtime
#

什么是编译时和运行时的概念？

编译时：编译器在进行语法检查的时候。

运行时：程序真正运行的时候。

所以说，我们有下面的内容：

标识符和编译时相对应，对象和运行时相对应。
作用域（scope）和编译时对应，生命周期（lifetime）和运行时相对应。
同时还有一个大杀器：constexpr

这个关键字的意思，指的是能够在编译时就确定常量（甚至函数），而不是运行时，从而把运行时开销转换成编译时间。

现在，对于简单的函数，不含new/delete，cin/cout，随机数生成的函数，我们都推荐使用constexpr。

需要注意的是，如果一个常量是在块作用域中，而且初始化用的是常量表达式（{} 零初始化 是常量表达式），那么它会自动成为常量表达式。

需要注意的是，在 C++11~20 的不同版本中，支持的类型略有差异，比如后期才支持流程控制的 for/while/if。

感觉 gemini 这么说不错：

标识符是编译时的抽象，是对象在代码中的名字和类型。对象是运行时的实体，是标识符所代表的内存和数据。

cmake 的一些使用方法（对于多文件/引入 libs）
#

加入这一行把需要的头包含进来，就可以直接在#include 里面写.h的文件了，无须写相对路径。
```
target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
```
在 cmake 3.30 之后，引入 Boost 直接用find_package(Boost)就好。

Best Practise
#

尽量在使用一个变量的正前面初始化。
尽量不要使用无符号整形，因为其具有的环绕特性会在一些行为（比如与有符号整数比较）上面让人难以调试。

给老机 x200 刷开源 BIOS--Coreboot！

Sat, 30 Aug 2025 12:33:31 +0800

这篇文本来是想写一下升级过程的，因为我在家里面翻出了这台 x200，也算是我早期用得比较久的本子了（B 站就是在这上面注册的）。

出于情怀，给它换了无线网卡，换了风扇，内存 4G->8G，换了原来坏了的键盘，总共没超过 200 元。

不过暂时没带来学校，所以图片的话，以后再补充吧。

刷入 Coreboot 注意事项
#

这里记载了折腾过程中遇到的坑。

请不要购买 CH341A！
#

为什么我会在这里得出跟 libreboot 一样的结论呢？

CH341A 无法设置 spispeed，而是默认 2M，这就造成一个问题，如果你的连接质量不好的话，这已经是一个相当高的速率了。可能会使得你根本没法看到你的芯片读取到。这里还是推荐买正版的 pico 吧，这玩意用的 buck-boost 电路，相比国产的 pico 来说，发热肯定会小不少，这可能对稳定刷写有一定的帮助。

刷写
#

在libreboot 的教程中，告诉你1, 9脚分别是 WP/HOLD，据说主板自带上拉电阻，所以不用连接。

经过测试，发现夹子连接正确的话，这两个脚会有 3.1v 左右的电压，稍微低了一点但是不影响。

如果原始的固件你可能根本刷不进去，写入没一会就提示擦除失败，我试了连接这两个脚是无关事项，所以后来者可以不用连接。

请看过程：

❯ flashprog -p serprog:dev=/dev/ttyACM0,spispeed=16M -c "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" -w x200_bios.rom

Using clock_gettime for delay loops (clk_id: 1, resolution: 1ns).
serprog: Programmer name is "pico-serprog"
Found Macronix flash chip "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" (8192 kB, SPI) on serprog.
Reading old flash chip contents... done.
Erasing and writing flash chip... FAILED at 0x00130000! Expected=0xff, Found=0x2f, failed byte count from 0x00130000-0x00137fff: 0x44aa
ERASE FAILED!
FAILED!
Uh oh. Erase/write failed. Checking if anything has changed.
Reading current flash chip contents... done.
Apparently at least some data has changed.
Your flash chip is in an unknown state.

那这个问题如何解决呢？答案是先擦除，再写入。

像这样：

❯ flashprog -p serprog:dev=/dev/ttyACM0,spispeed=16M -c "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" -E

...
Using clock_gettime for delay loops (clk_id: 1, resolution: 1ns).
serprog: Programmer name is "pico-serprog"
Found Macronix flash chip "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" (8192 kB, SPI) on serprog.
Erasing flash chip... Erase done.

然后就可以完美写入了：

❯ flashprog -p serprog:dev=/dev/ttyACM0,spispeed=16M -c "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" -w x200_bios.rom

...
Using clock_gettime for delay loops (clk_id: 1, resolution: 1ns).
serprog: Programmer name is "pico-serprog"
Found Macronix flash chip "MX25L6436E/MX25L6445E/MX25L6465E/MX25L6473E/MX25L6473F" (8192 kB, SPI) on serprog.
Reading old flash chip contents... done.
Erasing and writing flash chip... Erase/write done.
Verifying flash... VERIFIED.

提醒一句，尽量不要接在 hub 或者台式机的前面板，很可能会供电不足导致写入之后验证失败。

如果杜邦线的长度太长（最好 10cm），夹子的质量不好，可能会导致你根本无法用 16M 的 spispeed 写入，甚至根本没法读取到芯片，经过我测试，现在我手上的这套设备已经不太行了，只能在 64K 的速度稳定写入，这消耗了大概 50 分钟进行一轮读取 - 擦除/写入 - 读取，所以当你成功刷入 coreboot 后，最好保守一点，直接在目标机子上面刷吧。

Immortalwrt：IPv6、VLAN 与 NDP 代理

Sat, 19 Jul 2025 14:15:52 +0800

前言
#

早年接触过 wrt，但是那时候用的还是 7621 的设备，使用 mtk 开源驱动后信号会变得非常差，闭源驱动会出现死机的情况。如今入手 7981 的路由器，终于可以研究一下配置以及日用了。

IPv6 上网
#

想让路由器下面的设备上网，无非就这么几种方式：

PD(Prefix Delegation): 上级下发 ipv6 的/56 或者/60 的前缀，可以自己划分子网使用。
NDP Proxy: 上级通过 SLAAC 分配 ipv6 地址，只开启了 O 标志，获得一个/64 的地址的时候使用。
NPTv6: 你有多条宽带，需要做负载均衡。
NAPTv6: 上级只允许通过 DHCPv6 获取地址（一般是学校之类需要强管理或者认证的场景），获得一个/128 的地址。

欸，这时候有人问，/128 不是也可以使用 ndp 代理吗？

理论上确实可行，但是很多 DHCPv6 服务器并不支持代理获取，下面这个tcpdump结果说明了这一点：

root@ImmortalWrt:~# tcpdump -i eth1 udp port 546 or udp port 547
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), snapshot length 262144 bytes
15:03:40.878466 IP6 fe80::aaaa.546 > ff02::1:2.547: dhcp6 solicit
15:03:40.880132 IP6 fe80::bbbb.547 > fe80::aaaa.546: dhcp6 advertise
15:03:42.905527 IP6 fe80::aaaa.546 > ff02::1:2.547: dhcp6 request
15:03:42.908198 IP6 fe80::bbbb.547 > fe80::aaaa.546: dhcp6 reply
15:04:39.149414 IP6 ImmortalWrt.lan.547 > ff05::1:3.547: dhcp6 relay-fwd
15:04:40.188299 IP6 ImmortalWrt.lan.547 > ff05::1:3.547: dhcp6 relay-fwd
15:04:42.189520 IP6 ImmortalWrt.lan.547 > ff05::1:3.547: dhcp6 relay-fwd

使用 ff05 的广播根本就不回你。

NDP 代理
#

在路由器上面这样设置：

wan6

DHCP 服务器-IPv6 设置：

指定的主接口（打勾）
RA 服务：中继模式
DHCPv6 服务：中继模式
NDP 代理：中继模式
学习路由（打勾）

br-lan

DHCP 服务器-IPv6 设置：

指定的主接口（不允许选择了）
RA 服务：中继模式
DHCPv6 服务：中继模式
NDP 代理：中继模式
学习路由（打勾）
NDP 代理从属设备（打勾）

这样操作相当于透传了上级路由的 RA（路由器通告），上面怎么样配置，你的局域网设备就是怎么样的，没法更改，当然如果你能获取到/64 的前缀，那么下面的设备一般来说也没有问题。

前缀下发
#

这当然是最推荐的方式了。

在现代的类 wrt 上面，使用PPPoE在 wan 口上拨号，同时在高级设置里面开启获取 IPv6 地址为自动，如果你的 ISP 有 IPv6 支持，会自动产生一个虚拟动态接口wan_6。一般这个接口能获取到一个/64 的地址和 IPv6-PD，这是我们能分配的前提条件。

我的配置是这样的：

RA 服务：服务器模式
DHCPv6 服务：已禁用
NDP 代理：已禁用

使用简单的路由通告配置
#

在家用的小型网络中，完全可以做到不架设 DHCPv6 服务器，只通过 RA 就可以实现基本的配置了，请看这个包：

root@t-router:~# tcpdump -nvi br-lan ip6[40] == 134
tcpdump: listening on br-lan, link-type EN10MB (Ethernet), snapshot length 262144 bytes
10:35:28.476086 IP6 (flowlabel 0x4f20d, hlim 255, next-header ICMPv6 (58) payload length: 144) fe80::aaaa > ff02::1: [icmp6 sum ok] ICMP6, router advertisement, length 144
 hop limit 64, Flags [none], pref medium, router lifetime 1800s, reachable time 0ms, retrans timer 0ms
 source link-address option (1), length 8 (1): aa:aa:aa:aa:aa:aa
 mtu option (5), length 8 (1): 1492
 prefix info option (3), length 32 (4): 2409:xxxx:xxxx:13a::/64, Flags [onlink, auto], valid time 5400s, pref. time 2700s
 route info option (24), length 24 (3): 2409:xxxx:xxxx:130::/60, pref=medium, lifetime=1800s
 rdnss option (25), length 24 (3): lifetime 1800s, addr: 2409:xxxx:xxxx:13a::1
 dnssl option (31), length 24 (3): lifetime 1800s, domain(s): lan.
 advertisement interval option (7), length 8 (1): 600000ms

几个重要的信息全部体现在这个里面了：

地址：

没有配置 Flag，说明是 Stateless，设备自己生成配置，是否开启 RFC4941（隐私地址）由设备自己决定。

不过无状态自动配置要求地址的前缀必须是/64 以上的，否则会破坏这一行为。

网关：

规定路由通告必须使用 fe80 开头的本地地址来发送路由通告，只要路由存活时间不为 0，那么下面的设备就可以使用这个地址当做默认路由。

使用rdnss option来配置 DNS。

Windows 在大概 1709 这个版本之后支持rdnss了，其他系统应该都支持吧？

使用dnssl option来配置 DNS 搜索域。

这个感觉意义不大，因为使用 DHCPv6 才会解析主机名.lan，这个使用 DHCPv4 已经足够了。

不过注意不要设置成.local，因为 mDNS 会使用这个域名导致冲突，而 mDNS 会自动发现的。

如果你有/60 的前缀，可以在高级设置里面填写 IPv6 分配提示，4 位正好可以填一位 16 进制数，0-f，以此类推/56 可以填两位，从而划分多个 IPv6 子网。

像我就是填了a。

使用 DHCPv6
#

如果设备比较老，可能还是得开启 DHCPv6，办法就是把 DHCPv6 服务设置成服务器模式。

这时候就可以在 RA 设置里面的 RA 标记开启几个选项，让设备使用 DHCPv6 服务，这里配置项目已经讲解得很明白，我就不多说了，直接贴上来：

RA 标记

受管配置 (M)
受管地址配置 (M) 标记表明可以通过 DHCPv6 获取 IPv6 地址。
其他配置 (O)
其他配置 (O) 标记表明其他信息，如 DNS 服务器，可以通过 DHCPv6 获得。
移动家乡代理 (H)
移动 IPv6 家乡代理 (H) 标记表明该设备在此链路上还充当移动 IPv6 家乡代理。

DHCPv6 还可以配置别的一大堆东西，比如 NTP 之类的，但是 v4 已经干了这一堆了，我觉得除非 v4 被完全替代，否则现阶段完全没有理由用。

NPTv6/NAPTv6
#

如果有多条宽带并且都有 PD，你可以内网分配一个 ULA 地址，然后在路由的时候进行前缀转换，这也是我们学校社团网络的做法。这种办法对于性能要求的不高，本身也算符合 IPv6 的实践。

但是如果你只能通过 DHCPv6 配到一个/128 的地址，那就没办法了，直接用动态地址伪装（masquerade）吧，一般的路由器都不会有硬件加速，所以网速不太行，但是如果是 IPv6 刚需也没有别的办法了。

我有点懒得写了，想用的可以参考南航校园网 OpenWRT 配置 IPv6 NAT6，我自己在学校里面配的过程已经忘记了，不过跟这个应该大差不差。

邻居协议
#

IPv6 相比 v4 的 b 就是不同，就是邻居协议取代 ARP，RA 实现了 DHCP 的基本功能。

路由器和客户端使用 NS（Neighbour Solicitation）和 NA（Neighbour Advertisement）来检测地址冲突，探测别的设备。

一个 SLAAC 的过程具体是这样：

连接到网络，先生成一个地址，用::发送到这个地址，看自己生成的fe80::/16有没有冲突，没有就使用。
向ff02::发送 RS，寻找路由器。
路由器默认会每隔几分钟发送 RA，接收到 RS 后，会尽快回复 RA 消息。
客户端自己生成一个全球唯一的可路由地址，然后再看有没有冲突，没冲突就开始使用这个地址上网。

VLAN 划分
#

出于管理需要，我决定在路由器上面划分 VLAN 了，不过我其实并没有另一台 VLAN 的交换机，所以说并不是满血的 VLAN。同时由于是新手，对于 VLAN 的理解肯定有不到位之处，请多包涵。

简单的概念
#

trunk：在这个通道上面跑的是打上不同 ID 的 VLAN。
access：某个端口，一般来说一个端口只分配给一个 VLAN ID。

在某个端口上面，选择了 VLAN ID，有不同的标志可以分配：

不属于：这个 VLAN 不分配到这个端口。
tagged：通过这个端口的数据包，都会被打上这个 VLAN 的 ID。
untagged：通过这个端口的数据包，如果有 VLAN ID，将会被删除掉。
是主 VLAN：如果从这个接口进来的数据包没有任何标记，就认为他是这个 VLAN ID 的。

划分
#

我的想法是，.1的网段分配给熟悉的设备上网，.2的网段分配给物联网设备，.3的网段分配给访客网络。

所以我在设备上的br-lan的网桥 VLAN 过滤是这么配置的：

这个本地指的是路由器的 CPU 可以识别这个 VLAN 的内容，从而对它进行设置 DHCP 服务器之类的操作。

路由器有三个口，我全部分配给了 VLAN1，同时设置为主 VLAN 接口（显示为*），这是因为我大概不会在这上面接物联网设备（因为都是 2.4G 的设备）和插入访客的网线。

这时候在接口里面就可以看到这些虚拟的 VLAN 设备了，为它们设置 DHCP 服务器，防火墙，保存。

在无线里面，可以创建很多个同频段的 SSID（不会有人才知道吧），但是信道是一样的，接口配置里面可以选择关联的网络，这里选上你设置防火墙的接口，这时候通过这个 SSID 收到的数据就会自动地被交换机打上 VLAN ID 了。

在防火墙里面可以做更加细致的管理，比如使用conntrack，只允许 LAN 区段的设备主动发起到 IOT 设备的连接，隔离访客网络和信任网络的区段，非常灵活。

这时原有配置使用br-lan的应用，记得修改为br-lan.1。

这里有一个我刚开始不明白的问题：外部网络根本不识别 VLAN ID，那么转发到 WAN 的流量为什么会自动把 VLAN 头给去掉呢？

其实不是主动去掉的，因为 VLAN 是二层的东西，路由（三层）和 VLAN 是两个相对独立的过程，跨局域网的时候需要换二层封装，所以 VLAN ID 自然没有了。

中国移动 RAX3000Me USB3.0 版折腾小记

Sat, 12 Jul 2025 13:47:15 +0800

前言
#

这几天在闲鱼蹲路由器，终于让我蹲到了一台 65 的 RAX3000Me，遂开始折腾。

买之前看了下恩山发现可以免拆，无非就是导出导入配置文件破解 ssh 呗，但是到手之后，发现我大意了。

这台没法按照标准流程¹破解密码，通过爬帖得知，无法导出配置的自己的加密都存在问题，没办法免拆。

那？！CH340，启动！

刷写教程
#

教程大部分都是参考这篇文章，在此感谢。

CMCC RAX3000Me 可通过 mtk_uartboot 启动刷机，拆机刷 OpenWRT/ImmortalWRT 无障碍！

拆机
#

先把贴纸撕下来，拧下两颗螺丝。

左手握着长边，右手握着短边，像这样：

用力往下掰，会出现一条缝，用薄点的拆机片或者卡片撬开，小心别把卡扣弄断了。

拧下 5 颗螺丝，卸下散热片，上面涂有硅脂，要稍微移动一下散热片才好下来，装回去的时候得重新涂一下。

（其实不卸下也行，但是我探针就太难插了）

推一下下面和右边的卡扣，把主板撬出来，小心不要弄断天线连接处了。

你会看到这样：

电源线左边，分别是GND TX 3.3v RX。

文件准备
#

准备好这些东西：

❯ ls -lah
总计 2.3M
drwxr-xr-x 1 texsd texsd 148 7月19日 14:11 .
drwx------ 1 texsd texsd 1.3K 7月18日 21:58 ..
-rw-r--r-- 1 texsd texsd 248K 7月14日 18:10 mt7981-cmcc_rax3000me-nand-ddr3-fip-fit.bin
-rwxrwxr-x 1 texsd texsd 206K 2024年 2月 2日 mt7981-ddr3-bl2.bin
-rwxr-xr-x 1 texsd texsd 1.9M 2024年 3月 2日 mtk_uartboot

天灵的 U-Boot

bl2 （预构建，也可自行编译）²

mtk_uartboot

打开你的shell，cd到此文件夹，连接你的 CH340，你应该能在设备管理器看到对应的串口。我是/dev/ttyUSB0，如果你使用 Windows，一般是COMX，请自行替换。

./mtk_uartboot -s /dev/ttyUSB0 -p ./mt7981-ddr3-bl2.bin -f mt7981-cmcc_rax3000me-nand-ddr3-fip-fit.bin --brom-load-baudrate 115200 --bl2-load-baudrate 115200 -a

这里要记得加-a，否则可能识别成 aarch32 导致超时。

这时候应该会提示：

mtk_uartboot - 0.1.1
Using serial port: /dev/ttyUSB0
Handshake...

准备完成！

刷入 UBOOT
#

把你的 CH340 插上线，用杜邦线什么的都行，但是最好有带弹簧的测试探针，这是我的工具：

找出 CH340 的GND RX TX，从左往右依次按上主板的触点（不用接 3.3v），这时候右手还可以操作电脑。

如果你不确定是否插好，可以退出 mtk_uartboot，打开任意串口工具并连接，直接插电启动，应该能看到调试信息。

确认插好了，就直接上电，大概 30 秒左右，mtk_uartboot 输出以下内容并交还 shell：

mtk_uartboot - 0.1.1
Using serial port: /dev/ttyUSB0
Handshake...
hw code: 0x7981
hw sub code: 0x8a00
hw ver: 0xca00
sw ver: 0x1
Baud rate set to 115200
sending payload to 0x201000...
Checksum: 0x55cf
Setting baudrate back to 115200
Jumping to 0x201000 in aarch64...
Waiting for BL2. Message below:
==================================
NOTICE: BL2: v2.10.0 (release):v2.4-rc0-5845-gbacca82a8-dirty
NOTICE: BL2: Built : 20:18:08, Feb 2 2024
NOTICE: WDT: Cold boot
NOTICE: WDT: disabled
NOTICE: EMI: Using DDR3 settings
NOTICE: EMI: Detected DRAM size: 512MB
NOTICE: EMI: complex R/W mem test passed
NOTICE: CPU: MT7981 (1300MHz)
NOTICE: Starting UART download handshake ...
==================================
BL2 UART DL version: 0x10
Baudrate set to: 115200
FIP sent.
==================================
NOTICE: Received FIP 0x3df58 @ 0x40400000 ...
==================================

然后路由器就会亮起蓝灯（正常进官方系统没联网是红灯），网线插 LAN 口连到电脑，输入192.168.1.1/uboot.html，上传之前下载的 uboot。

一些问题
#

mtk_uartboot异常退出，提示 coredump

这大概率是连接不好/接上了 3.3v。建议不要接 3.3v，否则每次连上都会导致 CH340 断开连接。

无论怎么尝试，总是提示Timeout waiting for specified message.

有下面两种情况：

第一种：没有加-d参数。

Jumping to 0x201000 in aarch32...
Waiting for BL2. Message below:
==================================
==================================
Timeout waiting for specified message.

这就是默认使用了aarch32，请严格按照上面的命令执行！

第二种：没识别出内存。

==================================
NOTICE: BL2: v2.10.0 (release):v2.4-rc0-5845-gbacca82a8-dirty
NOTICE: BL2: Built : 20:20:25, Feb 2 2024
NOTICE: WDT: Cold boot
NOTICE: WDT: disabled
NOTICE: EMI: Using DDR4 settings
NOTICE: EMI: Detected DRAM size: 0MB
==================================

你的 bl2 用错了，请确认你的 ddr 类型，或者尝试另外一种 ddr 类型。

第三种：是aarch64，但是没有输出。

Jumping to 0x201000 in aarch64...
Waiting for BL2. Message below:
==================================
==================================
Timeout waiting for specified message.

可能是以下情况：

自己编译的 bl2 没成功。
下载中出现损坏。
使用了 immortalwrt 官方的 preloader，此文件我试了很多次都没成功，原因未知。

刷入固件
#

新版固件
#

新版的immortalwrt（23.05 和我打算用的 24.10）已经在使用一种新的镜像文件*.itb，这个镜像同时包含dtb ramdisk kernel。想要详细了解的可以参考u-boot FIT image 介绍

直接刷入sysupgrade的itb可能会出现不成功的情况，表现为一直闪蓝灯，这里我们需要先刷入initramfs的itb，重启进入系统之后，再刷入对应的sysupgrade镜像。

请注意uboot版本可能与固件版本相关，经过测试天灵 25 年 3 月编译的uboot是可以使用我上面的方法刷入 237 固件。

padavanonly/immortalwrt-mt798x-6.6

旧版固件
#

如果你想使用原汁原味的immortalwrt-mt798x，你可能得使用原版的 hanwckf 的uboot，这个版本没有dhcp需要手动设置静态地址。建议使用 24.11 的版本，因为尝试了 22 年的版本发现不认复旦微的这颗 NAND，导致uboot无法启动，只能使用 CH340 重新刷一遍。

而且，使用最新源码编译出来会导致 wifi 设置中缺少加密方式的问题，此问题亦有在 issues 里面提及，但感觉修复的可能性不大。

参考
#

黑群晖与 PVE：SMART 修复与 ACL 权限

Mon, 07 Jul 2025 21:00:20 +0800

前言
#

这是一篇记录自己折腾的过程的文章，可能会随着我的折腾过程补充，可能开会补一点动机或者小技巧之类的，所以你看到的不一定是完整版~

直通 SATA 控制器的硬盘 SMART 修复
#

使用 PVE 直通我的 SATA 控制器进群晖，发现命令行的 SMART 的功能不正常，表现就是没法显示其中的详细信息，而且温度显示为 0°C。

虽然群晖里面显示有温度，但是最新的 DSM7.2.2 已经没法在桌面端读取 SMART 信息了，不知道是出于什么考虑。

在 shell 里面是这样的：

texsd@tnas ~ [2]> sudo smartctl -a /dev/sata1
smartctl 6.5 (build date Sep 26 2022) [x86_64-linux-5.10.55+] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF INFORMATION SECTION ===
Vendor: WDC
Product: WD40EJRX-89AKWY0
Revision: 0B80
User Capacity: 4,000,787,030,016 bytes [4.00 TB]
Logical block size: 512 bytes
Physical block size: 4096 bytes
LU is fully provisioned
Rotation Rate: 5400 rpm
Form Factor: 3.5 inches
Logical Unit id: 0x50014ee2bed41999
Serial number: WD-XXXXXXXXXXXX
Device type: disk
Local Time is: Thu Jul 10 21:23:30 2025 CST
SMART support is: Unavailable - device lacks SMART capability.
=== START OF READ SMART DATA SECTION ===
Current Drive Temperature: 0 C
Drive Trip Temperature: 0 C
Error Counter logging not supported
[GLTSD (Global Logging Target Save Disable) set. Enable Save with '-S on']
Device does not support Self Test logging

我问了下 Gemini，跟我说消费级主板不支持，叫我买 LSI 卡，我当时想麻烦了，亏我专门找一块 4SATA 的板子。

问题解决
#

我先是一通操作，把 SATA 控制器直通进 Arch 虚拟机，发现是能成功读取的。那说明是 DSM 出了点问题。在 RR 里面一通乱改添加smartctl，本来以为成了，结果接上三块硬盘，一看，只有其中一块是正常的。

看了网上一些教程，发现要手动指定设备类型，才能正确读出硬盘的 smart 信息。

群晖手动改了 sata 盘的名字，不是 sd[a-z]了，而是 sata[1-9]。所以我得这样获取：

sudo smartctl -d sat -a /dev/sata1

smartctl 6.5 (build date Sep 26 2022) [x86_64-linux-5.10.55+] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF INFORMATION SECTION ===
Device Model: WDC WD40EJRX-89AKWY0
Serial Number: WD-XXXXXXXXXXXX
LU WWN Device Id: 5 0014ee 2bed41999
Firmware Version: 80.00B80
User Capacity: 4,000,787,030,016 bytes [4.00 TB]
Sector Sizes: 512 bytes logical, 4096 bytes physical
Rotation Rate: 5400 rpm
Form Factor: 3.5 inches
Device is: Not in smartctl database [for details use: -P showall]
ATA Version is: ACS-3 T13/2161-D revision 5
SATA Version is: SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is: Thu Jul 10 21:33:49 2025 CST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled
=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
General SMART Values:
Offline data collection status: (0x00) Offline data collection activity
was never started.
Auto Offline Data Collection: Disabled.
Self-test execution status: ( 0) The previous self-test routine completed
without error or no self-test has ever
been run.
Total time to complete Offline
data collection: (41760) seconds.
Offline data collection
capabilities: (0x11) SMART execute Offline immediate.
No Auto Offline data collection support.
Suspend Offline collection upon new
command.
No Offline surface scan supported.
Self-test supported.
No Conveyance Self-test supported.
No Selective Self-test supported.
SMART capabilities: (0x0003) Saves SMART data before entering
power-saving mode.
Supports SMART auto save timer.
Error logging capability: (0x01) Error logging supported.
General Purpose Logging supported.
Short self-test routine
recommended polling time: ( 2) minutes.
Extended self-test routine
recommended polling time: ( 443) minutes.
SCT capabilities: (0x303d) SCT Status supported.
SCT Error Recovery Control supported.
SCT Feature Control supported.
SCT Data Table supported.
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
1 Raw_Read_Error_Rate 0x002f 200 200 051 Pre-fail Always - 0
3 Spin_Up_Time 0x0027 223 219 021 Pre-fail Always - 3850
4 Start_Stop_Count 0x0032 100 100 000 Old_age Always - 303
5 Reallocated_Sector_Ct 0x0033 200 200 140 Pre-fail Always - 0
7 Seek_Error_Rate 0x002e 200 200 000 Old_age Always - 0
9 Power_On_Hours 0x0032 056 056 000 Old_age Always - 32405
10 Spin_Retry_Count 0x0032 100 100 000 Old_age Always - 0
11 Calibration_Retry_Count 0x0032 100 100 000 Old_age Always - 0
12 Power_Cycle_Count 0x0032 100 100 000 Old_age Always - 203
192 Power-Off_Retract_Count 0x0032 200 200 000 Old_age Always - 79
193 Load_Cycle_Count 0x0032 200 200 000 Old_age Always - 233
194 Temperature_Celsius 0x0022 110 105 000 Old_age Always - 40
196 Reallocated_Event_Count 0x0032 200 200 000 Old_age Always - 0
197 Current_Pending_Sector 0x0032 200 200 000 Old_age Always - 0
198 Offline_Uncorrectable 0x0030 100 253 000 Old_age Offline - 0
199 UDMA_CRC_Error_Count 0x0032 200 200 000 Old_age Always - 0
200 Multi_Zone_Error_Rate 0x0008 100 253 000 Old_age Offline - 0
SMART Error Log Version: 1
No Errors Logged
SMART Self-test log structure revision number 1
Num Test_Description Status Remaining LifeTime(hours) LBA_of_first_error
# 1 Short offline Aborted by host 90% 32358 -
# 2 Short offline Completed without error 00% 32333 -
# 3 Short offline Completed without error 00% 25336 -
# 4 Short offline Completed without error 00% 25093 -
# 5 Short offline Completed without error 00% 15531 -
# 6 Short offline Completed without error 00% 15527 -
# 7 Short offline Completed without error 00% 15527 -
# 8 Short offline Completed without error 00% 7694 -
# 9 Short offline Completed without error 00% 6217 -
#10 Short offline Completed without error 00% 3870 -
#11 Short offline Completed without error 00% 3869 -
#12 Short offline Completed without error 00% 3868 -
#13 Short offline Completed without error 00% 3609 -
#14 Short offline Completed without error 00% 3598 -
#15 Short offline Completed without error 00% 3545 -
#16 Short offline Completed without error 00% 3524 -
#17 Short offline Completed without error 00% 3335 -
#18 Short offline Completed without error 00% 3033 -
#19 Short offline Completed without error 00% 0 -
#20 Short offline Completed without error 00% 0 -
#21 Short offline Completed without error 00% 0 -
Selective Self-tests/Logging not supported

确实获取到了，但是为什么呢？

问题溯源
#

得懂能行，更得明白为什么可以这样。

我去翻了smartctl的 manual，里面关于-d是这么写的：

...
smartctl guesses the device type if possible. If necessary, the '-d' option can be used
to override this guess.
...
-d TYPE, --device=TYPE
Specifies the type of the device. The valid arguments to this option are:
auto - attempt to guess the device type from the device name or from controller
type info provided by the operating system or from a matching USB ID entry in the
drive database. This is the default.
test - prints the guessed TYPE, then opens the device and prints the (possibly
changed) TYPE name and then exits without performing any further commands.
ata - the device type is ATA. This prevents smartctl from issuing SCSI commands
to an ATA device.
scsi - the device type is SCSI. This prevents smartctl from issuing ATA commands
to a SCSI device.
nvme[,NSID] - the device type is NVM Express (NVMe). The optional parameter NSID
specifies the namespace id (in hex) passed to the driver. Use 0xffffffff for the
broadcast namespace id. The default for NSID is the namespace id addressed by
the device name.
sat[,auto][,N] - the device type is SCSI to ATA Translation (SAT). This is for
ATA disks that have a SCSI to ATA Translation Layer (SATL) between the disk and
the operating system. SAT defines two ATA PASS THROUGH SCSI commands, one 12
bytes long and the other 16 bytes long. The default is the 16 byte variant which
can be overridden with either '-d sat,12' or '-d sat,16'.
If '-d sat,auto' is specified, device type SAT (for ATA/SATA disks) is only used
if the SCSI INQUIRY data reports a SATL (VENDOR: "ATA "). Otherwise device
type SCSI (for SCSI/SAS disks) is used.

好家伙！原来是给我自动在猜啊😲

康康你猜到了什么~

texsd@tnas ~> sudo smartctl -d test /dev/sata1
smartctl 6.5 (build date Sep 26 2022) [x86_64-linux-5.10.55+] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org

/dev/sata1: Device of type 'scsi' [SCSI] detected
/dev/sata1: Device of type 'scsi' [SCSI] opened
texsd@tnas ~ [255]> sudo smartctl -d test /dev/sata2
smartctl 6.5 (build date Sep 26 2022) [x86_64-linux-5.10.55+] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org

/dev/sata2: Device of type 'scsi' [SCSI] detected
/dev/sata2: Device of type 'scsi' [SCSI] opened
texsd@tnas ~ [255]> sudo smartctl -d test /dev/sata3
smartctl 6.5 (build date Sep 26 2022) [x86_64-linux-5.10.55+] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org

/dev/sata3: Device of type 'scsi' [SCSI] detected
/dev/sata3 [SAT]: Device open changed type from 'scsi' to 'sat'
/dev/sata3 [SAT]: Device of type 'sat' [ATA] opened

所以问题已经很清晰了，PVE 在把 SATA 控制器直通的时候，识别出了一点问题，没有正确的报告需要使用 sat(SCSI to ATA Translation)，同时 DSM 配套的smartctl太旧了，猜错了，没有猜到这一个 SCSI 控制器是需要使用 sat 来翻译，直接使用 SCSI 来获取 SMART 信息，就没法读取到正确的信息。

但是为什么是 SCSI 控制器？我不是把 PCIe 设备直通吗？

这还是挺奇妙的，因为 PVE 很懒，只想加载一个 VirtIO SCSI 驱动，不想再折腾一个 SATA 驱动，所以虚拟机看到的，是一个 SCSI 设备，想猜出是 sat，得靠点想象力。

但是新版的smartctl就成功了，~~这就不得不提 Arch 的滚动更新的优越性了~~

一些知识补充：

SCSI 并不是为了磁盘而生的，而是一个系统的接口，用于连接大量外围设备的。它的成本早期非常高昂，需要一个独立的 SCSI 控制器，所以只有高端工作站才用得起。八十年代，IBM 兼容机崛起，为了降低成本，人们开发了 ATA (IDE)，这个控制器的成本低廉，而且控制部分集成在硬盘上，大幅降低了成本。（这就是为什么 SAS 硬盘没法接在 SATA 控制器上，但是反过来就可以）

突然想起了*nix 和 dos 的斗争，当年的 dos 也太简陋了，连用户管理都没有，早年我说这设计那么垃圾的系统，自动补全又没有，用的逆天的反斜杠，怎么当时会抢占那么多市场？

但是人家确实打下了市场，就是因为硬件要求低。

所以说当时降本是当时时代的趋势，就算现在 SAS 阵列卡已经白菜价了，*nix 甚至占用比 Windows 还低，但是前者估计是不太可能回到消费级电子领域了，后者可能还有点希望，得指望 deepin 和信创了。

群晖的文件权限管理
#

我们已经早都知道，传统的 Linux 权限很简单而且很不方便，只能设置所有者、组和其他的权限，随后拓展出来的 ACL 规则则很灵活。但是群晖上面没有setfacl和getfacl之类的命令，取而代之的是synoacltool，应该是存了数据库以便 web 也能够正确使用这些权限。

我从旧 NAS 迁移过来的数据是使用 rsync 的，旧 nas 的权限管理比较混乱，导致所有存储的文件都是 UID0（root），迁移过来就造成了一些问题。

我不知道群晖是怎么实现网页可以读写的，但是我在 shell 里面就没法进入这些文件夹，此时就需要修复。

群晖提供的方便的 webui 来修改，在共享文件夹的子文件夹右键 - 属性 - 权限。此时会显示此共享文件夹默认配置的权限，点击下面的“应用到这个文件夹、子文件夹及文件”，保存。此时群晖就把这个文件夹改成 ACL 模式，使得在 shell 里面也能访问。

但是我有些疑问：

1. 为什么改 ACL 那么快？
#

当您在 File Station 的图形界面中勾选“应用到子文件夹…”时，您不是在运行一个简单的脚本，而是在向 DSM 的核心服务发出一个高级指令。

这个指令更像是：“嘿，DSM 内核/存储服务，请你用最高效的方式，把这个 ACL 策略应用到整个文件夹树”。

DSM 的底层服务接收到这个“批发订单”后，会直接在内核层面或者以最优化的方式遍历文件系统的元数据 (metadata)。它可以批量处理、减少磁盘 I/O、避免不必要的上下文切换，效率远非 chmod -R 可比。

（摘抄自 Gemini 的回答）

2. ACL 是怎么工作的？
#

通过 ACL 管理的权限，我很意外的发现ls的显示已经不正常了。先举个例子：

ACL 规则是这样的：

texsd@tnas /volume1> sudo synoacltool -get 个人数据
ACL version: 1
Archive: has_ACL,is_support_ACL
Owner: [root(user)]
[0] group:administrators:allow:rwxpdDaARWc--:fd-- (level:0)
[1] group:custom_user:allow:rwxpdDaARWc--:fd-- (level:0)
[2] user:ActiveBackup:allow:rwxpdDaARWc--:fd-- (level:0)

可以看到，我在administrators组，有访问这个目录的权限。

我用ls查看权限：

texsd@tnas /volume1> ls -lah |grep 个人数据
drwxrwxrwx+ 1 root root 86 Jul 8 11:11 个人数据

我看到所有人都是有这个权限的。

guest 用ls查看权限：

guest@tnas:/volume1$ ls -lah | grep 个人数据
d---------+ 1 root root 86 Jul 8 11:11 个人数据

他没有任何权限，自然无法进入。

所以说，ACL 实际上改变了每个人看到的ls信息，在 ACL Mode 下，ls的输出已经不准确了。

3. 虽然说权限已经不准确了，那么所有者和组怎么样？
#

所有者和组仍然是以创建的用户为准的。谁创建的就是谁和启主要用户组（UID 显示的组）。

4. ACL 让我整个终端显示都是一片绿，为什么要在 POSIX 的 rwx 中设置为 777？
#

这里有一个小前置知识，如果其他用户可写，那么就会显示为绿色背景，如果文件可执行，就是显示为绿色字体。

因为 ACL 已经接管了权限管理，所以说 POSIX 显示的已经不够用了，比如说我上面的例子，有两个组都能访问这个文件夹，这个究竟如何界定？

如果使用 770，那么指的是 users 才有这个权限，实际上并不是。

所以，ACL 让每个人看到的东西不一样，这里的 777 表示有极大的权限，反之没权限的为 000，不是传统意义上面的 421 了。

~~我明白为什么 fish 不兼容 POSIX 了，因为确实不符合现代的一些实践了~~

参考
#

操作系统笔记：设备与驱动程序

Wed, 02 Jul 2025 11:28:27 +0800

插上u盘，是如何工作的？
#

usb控制器检测到电平变化 -> 硬件中断 -> 总线驱动捕获中断 -> sysfs创建设备目录和属性文件 -> 内核通过netlink发出uevent消息，广播

为什么udev的效率高？
#

udev被内核发送的uevent唤醒，而不是一直去轮询内核。
udev是并行工作的。在多个设备插入的时候，为每个事件启动一个处理实例。
udev使用的Netlink为传递短小的控制信息优化，比其他IPC更加轻量和迅速。
udev启动的时候会读取所有.rules文件，并解析成快速查询的内存数据结构。（这个就像mihomo一样，提前把规则处理成一个搜索树，使得匹配效率大幅提高）

I/O设备控制
#

X86同时支持MMIO/PMIO，ARM只支持MMIO。

通过一条线，一条指令就可以实现控制。

控制方式：

MMIO: 把外部控制寄存器映射到内存地址空间。使得一块特定的内存地址不再对应物理RAM。像这块内存地址写入，就是发送到硬件的控制寄存器，而从这里读取，就是获取寄存器当前的状态。
PMIO: （微机里面的IN/OUT指令）

使用内存的地址空间，不会造成存的浪费吗？

早期的32位系统，你安装了4G内存，会发现只有3.几可用，剩下为硬件保留的内存就是这个原因。一般都是被强制保留给PCIe的MMIO。

GPIO
#

一个通用的IO，有别于专用IO（USB/HDMI）。可以编程，可以作为输入或者输出。

输入模式：读取外部世界。通过这个引脚送过来的电平是高或者低来感知外部世界。
输出模式：设置这个引脚为高电平或者低电平，从而控制外部设备。

维护 Esxi 的小记

Fri, 20 Jun 2025 23:53:22 +0800

前言
#

学校社团的虚拟机空间快要不够了，派我进行整理以下虚拟机。看了一通，发现好多虚拟机是厚制备的，感叹当时买新硬盘的时候真是奢侈！

现在空间快要用尽了，用了百分之八十左右，大家还在讨论要不要给 esxi 加一块硬盘。我提出其实没必要，因为很多空间是可以压缩的，比如一台FreshCup机子，本身就只有一个服务，但是当时磁盘选了厚置备，只用了 13G，但是占用了快 50G，这真浪费啊！于是便有了这篇文。

初探 ESXi 内部结构
#

开始我脑子没转过来，还想着找一台大硬盘的电脑，用 WorkStation 来进行压缩。不知道是不是无线的问题，下载速度不过百兆出头，这对于几十个 G 来说真是挑战！

但是你看 ESXi 的那个 webui 叫作一个完成度低啊，根本找不到转换的选项。

我之前也听说过 ESXi 用的是定制的系统，但是人家竟然能用 22 端口访问，登录进去甚至还有 bash，GNU 的基本工具还是有的，但是稍微常见一点的工具比如curl就没有了。

这个系统是什么呢？
#


[root@localhost:/vmfs/volumes/65522cf6-65fd4b38-f248-6c92bfca102e] uname -a
VMkernel localhost 7.0.3 #1 SMP Release build-21686933 Apr 28 2023 08:42:51 x86_64 x86_64 x86_64 ESXi

呃呃，VMkernel，大概是基于unix定制的吧，但是我觉得也有可能是linux。

看看硬盘占用情况？
#


[root@localhost:/vmfs/volumes/65522cf6-65fd4b38-f248-6c92bfca102e] df -h
Filesystem Size Used Available Use% Mounted on
VMFS-6 745.0G 481.7G 263.3G 65% /vmfs/volumes/99-datastore0
VFFS 103.5G 3.5G 100.0G 3% /vmfs/volumes/OSDATA-654f485c-fa8f3400-bbb9-6c92bfca102e
vfat 4.0G 204.8M 3.8G 5% /vmfs/volumes/BOOTBANK1
vfat 4.0G 64.0K 4.0G 0% /vmfs/volumes/BOOTBANK2

（完成了才贴上来，假装没看到剩余的 263G 空间吧）

有什么特殊工具？
#

当然，这个系统里面有一大堆 vm 开头的工具，这就是为了命令行管理用的 ESXi 专有工具了。

我主要用的就是vmkfstools这个工具。

这个工具用起来思路也非常清晰：

**用-i来指定输入的虚拟磁盘。**这里注意是那个后缀最短的vmdk，如果是多文件的话，这个文件包含了一个虚拟磁盘使用的所有文件清单。
用-K压缩现有的精简置备磁盘。
用-d thin指定创建一个精简置备磁盘

最后跟上你要输出的磁盘名字，跟不跟都行，看参数。

坑点
#

本来这块硬盘空间就不剩多少了，所以我开始直接根据厚置备的磁盘生成一个精简置备的磁盘。因为按照正常的逻辑，生成的精简置备磁盘大小只有十几 G，那么我现有的空间还是够的。

结果失败了，试了好几次，都不行。（坑点 1）

我决定把磁盘搞到电脑上面，用 WorkStation 来转换。转换也成功，生成的磁盘是我需要的精简类型，占用正常。然后我就转移回 ESXi 上面，结果导入失败。

ESXi 不支持多文件的磁盘格式，这台是 7.0。可能旧的确实不可以吧？（坑点 2）

我又创建了一个单文件的精简置备移回去，这时候我正好删除了其他不要的虚拟机，总空间>50G 了，传上去了我也没管这台是否占用了这么大的空间。

然后我觉得这样太费事了，怎么不能在主机上面直接压缩？接着我就使用那个命令行工具压缩，但是压了好几次，该填零的也用dd/sdelete填充了，但是使用ls发现显示的还是 50G！

我以为这是 bug，但是真正的问题在ls和vmfs上。（坑点 3）

众所周知，Android 上使用 KernelSU 的时候，有的人会看到自己的手机显示成使用 2T 的存储，但是事实上很多人根本没有 2T 的手机，这是因为稀疏文件（Sparse file）造成的。使用 ls 列出的就是 2T，我估计手机厂商获取的时候也是用类似的方法做统计，所以闹出了这一出。

其实还有别的例子，比如说 btrfs 就不能用du正确显示，就是因为文件系统的各种特性导致的。

所以说，其实我使用-K压缩，结果是成功的，而且使用du也可以直接看到，ESXi 的状态面板也可以直接看到存储被释放了。但是我怎么在这个坑上面找问题，找了那么久，唉唉唉

防火墙：iptables、nftables 与 firewalld

Fri, 25 Apr 2025 21:46:16 +0800

前言
#

其实防火墙这玩意，我三年前就接触过。那时候在用 iptables 来配置路由器的ipv6转发，照着教程抄完了也不知所云。

如今过去了那么久，知识储备多了那么一点点，正好有需求，就重新了解了一下。

iptables
#

iptables，这玩意算是个古董了，大概在 21 世纪初就有了。不过毕竟是老东西，现在大部分旧设备都是用的它，很多软件在修改防火墙规则的时候也只改它。

提起iptables，我们也许会想到五链四表，不过一般来说，知道nat和filter表就已经足够完成 80% 的工作了（ipv4），我在archwiki 的 iptables章节翻到这张图，也许能够有助于理解：


 XXXXXXXXXXXXXXXXXX
 XXX Network XXX
 XXXXXXXXXXXXXXXXXX
 +
 |
 v
 +-------------+ +------------------+
 |table: filter| <---+ | table: nat |
 |chain: INPUT | | | chain: PREROUTING|
 +-----+-------+ | +--------+---------+
 | | |
 v | v
 [local process] | **************** +--------------+
 | +---------+ Routing decision +------> |table: filter |
 v **************** |chain: FORWARD|
**************** +------+-------+
Routing decision |
**************** |
 | |
 v **************** |
+-------------+ +------> Routing decision <---------------+
|table: nat | | ****************
|chain: OUTPUT| | +
+-----+-------+ | |
 | | v
 v | +-------------------+
+--------------+ | | table: nat |
|table: filter | +----+ | chain: POSTROUTING|
|chain: OUTPUT | +--------+----------+
+--------------+ |
 v
 XXXXXXXXXXXXXXXXXX
 XXX Network XXX
 XXXXXXXXXXXXXXXXXX

这里的 Network，指的就是不同的网卡接口。

接着我来说说自己的理解：

啥表啥链？
#

filter表最简单，也是默认的表。它只有OUTPUT，INPUT，FORWARD链。这几个顾名思义，分别是来源本机，目标本机，经过本机的数据包。一般来说，
- OUTPUT 的默认规则是ACCEPT，也就是允许所有来源本机的数据包发出。
- INPUT 的默认规则是DROP，也就是不允许外来的数据包访问本机。我们一般监听的端口需要配置例外的规则，否则就无法被访问。
- *FORWARD *也是DROP。默认不允许不同网络接口之间的数据包转发。想要转发不仅仅需要手动放行，还得开启内核的 IP 转发。
```
## 临时启用
sysctl -w net.ipv4.ip_forward=1
## 永久启用
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sysctl -p
```
  举个例子：
```
Chain FORWARD (policy DROP 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
1 52 ACCEPT all -- wg0 * 0.0.0.0/0 0.0.0.0/0
```
nat表这个表有四条链，不过我一般只用其中的两条：PREROUTING和POSTROUTING，分别处理端口映射以及 ip 伪装。
- PREROUTING 这一个链其实我接触得不多，因为基本都是在 ui 上面设置的。但是摸过 SAST 的 RouterOS 之后，那个 ui 配置起来就像是手搓iptables一样，我就马上理解了。一个例子就像这样：
```
Chain PREROUTING (policy ACCEPT 2885K packets, 212M bytes)
pkts bytes target prot opt in out source destination
16 952 DNAT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:22345 to:192.168.123.2:22
## 这里因为涉及到自定义链，我就直接合并了。
```
  你会注意到，policy为什么是ACCEPT？我觉得是因为如果不给你规则，路由也不会帮你转发，所以大家都说ipv4的nat安全，原来是这个意思。
- POSTROUTING 你是否想过，nat后的主机，是如何用路由器的 ip 进行通信的？这条链改写了对应目标的源 ip 地址和端口，然后再发出去。规则 SNAT 需要指定 ip，但是在家庭环境中，ip 通常是变化的，这时候神器MASQUERADE出现了，它可以动态的获取出口网卡的 ip 地址，把 ip 改写再发出去。至于出口怎么决定，那就是路由表的事情了。例子：
```
Chain POSTROUTING (policy ACCEPT 804K packets, 60M bytes)
pkts bytes target prot opt in out source destination
0 0 MASQUERADE all -- * ppp0 0.0.0.0/0 0.0.0.0/0
```

命令
#

iptables的命令非常的精简，看多了倒还不错，不过现在的风格倒变成自然语言了，像ip和nft之流。

iptables -t nat -nvL [CHAIN-NAME] #看 nat 表的规则，链名是可选的
iptables -nvL --line-numbers #看 filter 表的规则，filter 默认可以省略；--line-numbers 用于显示编号。

一些我常用的就一起放在这了：

ip6tables -A INPUT -p udp --dport 26741 -j ACCEPT # ip6tables 是用于控制 ipv6 的防火墙，我目前只接触了 filter 表，NPT 还不会...
iptables -A INPUT -i wg0 -j ACCEPT
iptables -A FORWARD -i wg0 -j ACCEPT
iptables -t nat -A POSTROUTING -o ppp0 -s 10.0.8.0/24 -j MASQUERADE --mode fullcone

-A是Append，-I是Insert，-D是Delete，据此可以精确的删除规则。

用行号也可以：iptables -D INPUT 2

补充
#

还有子链和其他表等其他内容，等到后面有时间再写吧。

nftables + firewalld
#

nftables是一个新的netfilter工具，firewalld是 RedHat 开发的一个防火墙前端。firewalld的默认后端是nft，这两者一般来说会配合起来使用。

直接操作底层的nft命令对我来说还是有点困难，这里就简单讲讲他们的结合使用吧。

为什么选择 firewalld 而不是选择 ufw 呢？

firewalld对于动态网络（比如笔记本在不同的热点之间切换）有很好的适配，具体体现在与NetworkManager之间的配合，使得不同的热点能够应用在不同的区域中，后面会讲讲配置过程。

永久和非永久配置
#

firewalld在设置防火墙的时候，默认是临时配置立即生效。如果想要配置永久规则，加上--permanent参数即可，记得使用firewall-cmd重新加载规则生效。

启动
#

一行命令就好：

sudo systemctl enable --now nftables firewalld

这样，系统就为我们配置了一个默认的防火墙，默认所有的网卡会在public区域，现在只有 22 入站才被允许。

区域
#

你应该发现，新的防护墙工具多了一个新概念叫作区域，不同的网卡可以分配到不同的区域。

先来看看有什么区域？

sudo firewalld --list-all-zones

部分输出：

...
home
target: default
ingress-priority: 0
egress-priority: 0
icmp-block-inversion: no
interfaces:
sources:
services: dhcpv6-client mdns samba-client ssh
ports:
protocols:
forward: yes
masquerade: no
forward-ports:
source-ports:
icmp-blocks:
rich rules:
...
public (default, active)
target: default
ingress-priority: 0
egress-priority: 0
icmp-block-inversion: no
interfaces:
sources:
services: dhcpv6-client ssh
ports:
protocols:
forward: yes
masquerade: no
forward-ports:
source-ports:
icmp-blocks:
rich rules:
trusted
target: ACCEPT
ingress-priority: 0
egress-priority: 0
icmp-block-inversion: no
interfaces:
sources:
services:
ports:
protocols:
forward: yes
masquerade: no
forward-ports:
source-ports:
icmp-blocks:
rich rules:
...

如果设置了tun模式，你会发现它无法联网了。

将网卡分配到区域
#

分配 tun
#

我们使用firewalld来配置规则。

通过上面的输出可以知道，trusted区域是允许所有流量的，我们把Mihomo加到trusted区域：

firewall-cmd --zone=trusted --add-interface=Mihomo --permanent
sudo firewall-cmd --reload

## 验证
firewall-cmd --get-zone-of-interface=Mihomo ## 返回 trusted

这里有个小坑，我加入之后发现还是不行，一看日志发现数据包全被丢弃了。~~折腾半天发现重启解决了，我：？？？~~

真正的隐藏 boss 在后面！

反向路径过滤

分配 wlan0
#

如果是便携的设备，我们会连接到不同的热点，有公用的也有家里的，家里可以开放多一点权限，而公用的则不需要。

这一部分由 NetworkManager 配置：

nmcli connection modify "SAST" connection.zone "home"

## 验证
sudo nmcli connection show SAST | grep connection.zone

## 返回
connection.zone: home

这样只有连接到指定的热点名称的时候，才会切换 wlan0 到 home 区域，其他都是 public 区域。

开放特定服务和端口
#

firewalld 事先定义了一些服务需要的端口，可以在/usr/lib/firewalld/services/找到，这些配置文件以xml格式存储。

添加服务和端口的时候，别忘了指定当前区域。如果不指定，那么默认是在 public 区域添加规则的。

如果你需要的服务恰好在里面，就可以很方便的添加：

sudo firewall-cmd --zone=home --add-service=kdeconnect --permanent
sudo firewall-cmd --reload

如果这个端口是你自己定义的，可以这样子：

sudo firewall-cmd --add-port=8000/tcp --zone=home --permanent
sudo firewall-cmd --reload

然后查看：

sudo firewall-cmd --zone=home --list-all

## 输出
home (active)
 target: default
 ingress-priority: 0
 egress-priority: 0
 icmp-block-inversion: no
 interfaces: wlan0
 sources:
 services: dhcpv6-client kdeconnect mdns samba-client ssh
 ports: 8000/tcp
 protocols:
 forward: yes
 masquerade: no
 forward-ports:
 source-ports:
 icmp-blocks:
 rich rules:

反向路径过滤
#

反向路径过滤，简称 rpfilter。这一个功能在 ipv4 时代，是由内核实现的。在内核文档中是这么写的：

/proc/sys/net/ipv4/* Variables:
rp_filter - INTEGER
0 - No source validation.
1 - Strict mode as defined in RFC3704 Strict Reverse Path
Each incoming packet is tested against the FIB and if the interface
is not the best reverse path the packet check will fail.
By default failed packets are discarded.
2 - Loose mode as defined in RFC3704 Loose Reverse Path
Each incoming packet's source address is also tested against the FIB
and if the source address is not reachable via any interface
the packet check will fail.
Current recommended practice in RFC3704 is to enable strict mode
to prevent IP spoofing from DDos attacks. If using asymmetric routing
or other complicated routing, then loose mode is recommended.
The max value from conf/{all,interface}/rp_filter is used
when doing source validation on the {interface}.
Default value is 0. Note that some distributions enable it
in startup scripts.

顺带一提，ip_forward也是在这个地方配置的。

这里告诉我们，0禁用反向路径过滤，1开启严格的反向路径过滤（反向路径必须是最佳路由），2开启宽松的反向路径过滤（只要反向路径路由可达即可）。

默认是不开启反向过滤的，但是似乎防火墙会给每个网卡加上一个2？由于目前手上没有无防火墙的机器，暂时无法验证…

但是如果你装的是firewalld，默认的反向过滤是全部严格的。这时得到/etc/firewalld/firewalld.conf改成这样：

IPv6_rpfilter=loose

才能禁用反向路径过滤。由于firewalld在 nft 中配置的表是只读的，只能由它改写，所以去删掉它的规则或者尝试绕过都是没用的。~~别骂了别骂了~~

Mihomo会导致出现很多的drop数据包，其中一部分就是rpfilter引起的，日志类似这样：

5月 18 23:18:08 texsd-spin kernel: rpfilter_DROP: IN=Mihomo OUT= MAC= SRC=2a01:04f9:3081:4e4b:0000:0000:0000:0002 DST=fdfe:dcba:9876:0000:0000:0000:0000:0001 LEN=80 TC=0 HOPLIMIT=64 FLOWLBL=1037094 PROTO=TCP SPT=443 DPT=22000 WINDOW=64260 RES=0x00 ACK SYN URGP=0

导致所有的ipv6能ping通但是无法访问，改成宽松后解决。

管理
#

禁用日志
#

这是一个标准选项，所以不需要加--permanent。

我比较建议把日志调成unicast。否则如果你局域网中广播的设备很多的话，journalctl会被淹没。

sudo firewall-cmd --set-log-denied=unicast

其他
#

我觉得firewalld的 man page 写得很清晰，去看它是一个很好的选择。

man 1 firewall-cmd

总结
#

目前来说个人主机拥抱 firewalld + nftables 更加合适，因为它们提供了更灵活的规则，也拥有更高效的性能。但是服务器上不建议安装 firewalld，因为很多软件是直接通过添加 nftables 规则的，还有很大一部分老软件会添加 iptables 规则。当然 nftables 也做了兼容，iptables-nft这个包会把 iptables 类的指令自动翻译成 nftables 规则进行加载。此外，iptables-translate可以把 iptables 指令翻译成 nftables，便于学习和迁移。

nftables 是未来的防火墙！~~但是目前直接使用的真的太少了~~

字形、字体以及我的配置

Fri, 18 Apr 2025 23:38:19 +0800

终于受不了终端里那丑得要死的宋体了，开干！XML？拿来把你！

衬线，无衬线，等宽
#

这大概是三种最常见的字形了。

衬线（Serif)
#

简单来说，就是字体有小学练字的时候的老师要求你有的那种笔锋。

对于英文版来说，很常见的是Times New Roman ，需要注意的是这是一个版权字体。

而对于中文版，衬线字体一般跟宋体都是同一个意思了。不过名字还是会有区分：宋体，仿宋（这个公文用的很多）,楷体，这些字体的版权都是归属于中易中标，得小心。还有一部分宋体是方正的，名字就是方正 xx。

无衬线（Sans-Serif）
#

人们发现，衬线字体虽然打印出来显示效果不错，但是在屏幕上，每个字是由像素点组成的，在早期分辨率差的屏幕上，衬线字体的各种装饰部分显示效果也很差。于是就出现了无衬线的字体，简化了装饰部分，使得在屏幕上更易读。

中文，微软雅黑，算是一个历史包袱非常重的字体了，在 windows 上几乎是独占，效果也比其他字体好，后面还出现了一个等线，在雅黑的基础上简化了。微软名字命名的，优化好点也正常吧（？但是这是微软的小动作！

英文，Arial，这个字体名字不怎么出名，但是你在显示器上看到的，基本都是它。

等宽（monospace）
#

这一种字体是专为代码显示设计的，因为缩进的时候能够更好的对齐，在终端中，也能让 Tab 更好的对齐；而且易于分辨I l以及O 0。

我感觉中文和英文的这些名字，常人应该很少能听到吧？只怪 Windows 和生态的软件把用户驯化得太好了，如果不是用 Arch，我可能也不会去了解这些内容。

你问我现在用的什么字体呢？FiraMono Nerd Font以及Noto Sans Mono CJK SC，这两种字体都是开源的，接下来讲一下他们。

开源字体
#

对于英文字体来说，有一套字体叫做liberation，全面实现了对 Windows 上面的常见字体的兼容，这套字体是红帽开发的。

而对于中文，则是思源/Noto

为什么要 Adobe 和 Google 要开发思源字体/Noto CJK 呢？

Google 在 Android 4.4 之前使用的字体问题很多，不支持的字符有 fallback，导致显示效果不一致。而 Adobe 的软件使用字体会造成版权争议，同时有自己的字体部门。两家公司一拍即合，由 Google 出资、提供建议，Adobe 设计字体，最终出现了这套字体。这套字体可以说是开源的大胜利了，后面还有以此衍生的更纱黑体。

还有别的开源字体，霞鹜文楷，得意黑什么的，就不一一介绍了。

值得一提的是，这不是第一套中文的开源字体。在 AUR 上你还能看到文泉驿这款字体，至今有二十年了。虽然它的名字很诗意，但是在 Noto 之后，已经鲜有人用了，也没人维护了。

思源黑体极大的提高了 Linux 图形界面上面的字体显示体验，不过我早期使用的时候没注意，从 AUR 下载了 Windows 的兼容字体，使得终端一直在随意 fallback 一些奇怪的字体（捂脸），最近才决定了解一下，从而有了这篇东西。

系统字体调优
#

Arch
#

管理字体，现代的 Linux 系统基本都是 fontconfig 了。我们主要是用fc-cache,fc-match两个命令。

先看看你的三种字体会匹配什么？

fc-match serif # 添加-a 参数可以显示依次匹配的字体
fc-match sans-serif
fc-match monospace

我的是这样的：

[texsd@texsd-spin ~]$ fc-match sans-serif
NotoSansCJK-Regular.ttc: "Noto Sans CJK SC" "Regular"
[texsd@texsd-spin ~]$ fc-match serif
NotoSerifCJK-Regular.ttc: "Noto Serif CJK SC" "Regular"
[texsd@texsd-spin ~]$ fc-match monospace
FiraMonoNerdFontMono-Regular.otf: "FiraMono Nerd Font Mono" "Regular"

如果群魔乱舞的话，还是先去装一个noto-cjk包吧。

安装字体包在/usr/share/fonts目录，安装时会自动执行fc-cache -fv来刷新字体缓存，你也可以手动来刷新它们。

我还额外安装了otf-firamono-nerd来实现 shell 的 emoji 图标，记住不！要！安！装！nerd-fonts 包集！那总共有7GiB+！

我是强烈推荐去修改默认字体配置文件的，虽然 xml 的可读性确实不怎么样，但是根据别人的改嘛，查找替换也不算太难。这里就贴一下我的方案吧：

~/.config/fontconfig/conf.d/99-notocjk.conf

<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'urn:fontconfig:fonts.dtd'>
<fontconfig>
 <!-- 配置黑体-->
 <match target="pattern">
 <test compare="contains" name="lang">
 <string>zh</string>
 </test>
 <test name="family" qual="any">
 <string>sans-serif</string>
 </test>
 <edit binding="strong" mode="prepend" name="family">
 <string>Noto Sans CJK SC</string>
 </edit>
 </match>
 <!-- 配置宋体-->
 <match target="pattern">
 <test compare="contains" name="lang">
 <string>zh</string>
 </test>
 <test name="family" qual="any">
 <string>serif</string>
 </test>
 <edit binding="strong" mode="prepend" name="family">
 <string>Noto Serif CJK SC</string>
 </edit>
 </match>
 <match target="pattern">
 <test name="family" qual="any">
 <string>monospace</string>
 </test>
 <edit binding="strong" mode="prepend" name="family">
 <!-- 这里等宽配置了两个字体，原因是FiraMono没有中文的等宽字体，下面写上Noto的等宽字体就可以自动fallback了-->
 <string>FiraMono Nerd Font Mono</string>
 <string>Noto Sans Mono CJK SC</string>
 </edit>
 </match>
 <dir>~/.local/share/fonts</dir>
</fontconfig>

懒得在 kde 里面设置的话，可以直接把这个放到 conf.d:

<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'urn:fontconfig:fonts.dtd'>
<fontconfig>
 <!--
 Artificial oblique for fonts without an italic or oblique version
 -->
 <match target="font">
 <!-- check to see if the font is roman -->
 <test name="slant">
 <const>roman</const>
 </test>
 <!-- check to see if the pattern requested non-roman -->
 <test compare="not_eq" name="slant" target="pattern">
 <const>roman</const>
 </test>
 <!-- multiply the matrix to slant the font -->
 <edit mode="assign" name="matrix">
 <times>
 <name>matrix</name>
 <matrix>
 <double>1</double>
 <double>0.2</double>
 <double>0</double>
 <double>1</double>
 </matrix>
 </times>
 </edit>
 <!-- pretend the font is oblique now -->
 <edit mode="assign" name="slant">
 <const>oblique</const>
 </edit>
 <!-- and disable embedded bitmaps for artificial oblique -->
 <edit mode="assign" name="embeddedbitmap">
 <bool>false</bool>
 </edit>
 </match>
 <!--
 Synthetic emboldening for fonts that do not have bold face available
 -->
 <match target="font">
 <!-- check to see if the weight in the font is less than medium which possibly need emboldening -->
 <test compare="less_eq" name="weight">
 <const>medium</const>
 </test>
 <!-- check to see if the pattern requests bold -->
 <test compare="more_eq" name="weight" target="pattern">
 <const>bold</const>
 </test>
 <!--
 set the embolden flag
 needed for applications using cairo, e.g. gucharmap, gedit, ...
 -->
 <edit mode="assign" name="embolden">
 <bool>true</bool>
 </edit>
 <!--
 set weight to bold
 needed for applications using Xft directly, e.g. Firefox, ...
 -->
 <edit mode="assign" name="weight">
 <const>bold</const>
 </edit>
 </match>
 <match target="font">
 <edit mode="assign" name="rgba">
 <const>none</const>
 </edit>
 </match>
 <match target="font">
 <edit mode="assign" name="hinting">
 <bool>false</bool>
 </edit>
 </match>
 <match target="font">
 <edit mode="assign" name="hintstyle">
 <const>hintnone</const>
 </edit>
 </match>
 <dir>~/.fonts</dir>
 <match target="font">
 <edit mode="assign" name="antialias">
 <bool>true</bool>
 </edit>
 </match>
</fontconfig>

总共三段内容，分别对应衬线，无衬线，等宽，按照自己的喜好修改即可。不知道字体名字可以用fc-match -a查看引号内的字体名称，或者看桌面设置里面的字体选项。

Win
#

Windows 中文版默认是使用微软雅黑的，修改需要改注册表。所以一般来说我们都会在软件里面单独修改，像 Firefox，Windows Terminal，VSCode 都支持。而其他的应用我选择用微软雅黑，因为 Windows 运行的旧应用很多都是硬编码微软雅黑的，调整他们会导致一些奇怪的问题，下面说说。

这是个版权字体（属于方正）正因为如此应该不少人吃了官司吧（？

点阵字体和矢量字体
#

点阵字体是以前低分辨率的时代使用的，现在已经基本淘汰了。但是你可能偶尔还能看到有人发那些锯齿感字体非常严重的图片，那大概就是用 xp 截图出来的。

现代系统基本都是矢量字体，这些字体是通过贝塞尔曲线画出来的。Windows 为了兼容旧的程序和低分屏，要求字体都要支持 Hinting。而自带的微软雅黑对此有优化，别的字体就不太行。但是微软雅黑尽力了，没法避免 100% 下的字体发虚。所以还是换 4K 屏吧，200% 的比例放大下，字体渲染还是可以的。

想了解这篇细节，可以看看Windows 的字体渲染的一些鸟事

参考
#

https://github.com/oodzchen/dotfiles/blob/main/dot_config/fontconfig/fonts.conf

我的 ArchLinux 折腾记录

Mon, 09 Dec 2024 15:42:53 +0800

前言
#

暑假的时候在我的掠夺者·擎 neo 上面第一次纯手动安装了 Arch，过程很有意思，但是后面烂到家的 NV 驱动让我受不了。

我在 win 下喜欢开独显直连模式，但是在 arch 下就有很大问题：每次睡眠，内建显示器的亮度都会自动开到最大。

~~我试过很多办法，都很难实现记忆之前的亮度。只有在 BIOS 里面开启混合模式才会出现 intel_backlight，这真是太折磨了。~~

~~最后，我的评价是，别在日用的电脑上面用 n 卡和 linux！~~

其实是有办法的，给睡眠加个钩子保存亮度，然后唤醒的时候读取文件并还原亮度。也是勉强能用的。（果然水平提高了就有新办法

物色新机
#

作为一个穷学生，已经花了大几千实现臭打游戏的目标，无论怎么说都不太好再拿出几千买电脑。开始我把目标锁定在 3k 左右，然后降到 2k，最后 1k。

正好这段时间有国补，就在看鸡哥的 14x，但是各种说品控差让我望而却步。后面又看火影的 6800 二手，感觉周边又差一点。

怎么，你又开始后悔没有买 6800 以上的 u 了？！其实只是舍不得出那么多钱罢了！

几番挑选，我决定捡洋垃圾，目光投向了 chromebook。这样，就有了这篇文章的主角：Acer Spin713 二代 (cp713-2w)。在海鲜市场的 js 以 1050 的价格拿下。

配置是 i5-10210u，马甲什么的我不是很在意。我在意的是这块屏幕好像是夏老师之前提到的网格纱窗屏，凑近看确实观感不太好，其实，我根本不需要触摸屏的，但是换不得呀！

默念 1050…默念 1050…默念 1050…

安装过程
#

用 Arch 怎么能不手动安装呢？

但是 ArchInstall 真的太香了！连好网络分好区，设置好一些东西，直接重启就看到 sddm 了。

然而，像装黑苹果一样，大家都是装完了然后开系统信息截屏。装完 Arch 你也可以fastfetch，然而，这一切仅仅是个开始…

输入法设置
#

首先得有输入法吧？

我用的是 fcitx5 + rime + 雾凇拼音的组合，最终效果还不错。

首先安装 fcitx5、rime 和雾凇拼音：

paru -S fcitx5 fcitx5-rime rime-ice-git ## 可以用archlinuxcn源的

根据雾凇拼音的配置方案，把这段配置加入 rime 输入法：

# $HOME/.local/share/fcitx5/rime/
patch:
 # 仅使用「雾凇拼音」的默认配置，配置此行即可
 __include: rime_ice_suggestion:/
 # 以下根据自己所需自行定义，仅做参考。
 # 针对对应处方的定制条目，请使用 <recipe>.custom.yaml 中配置，例如 rime_ice.custom.yaml
 __patch:
 key_binder/bindings/+:
 # 开启逗号句号翻页
 - { when: paging, accept: comma, send: Page_Up }
 - { when: has_menu, accept: period, send: Page_Down }

进入设置里面，输入与输出 - 键盘 - 虚拟键盘把 fcitx5 打开，这时候才会在语言和时间下面出现输入法。如果因为 kde 的 bug 出不来的话，重启或者重装吧。
输入法 - 添加输入法，选择中州韵。这里建议点击中州韵的配置，然后把“切换输入法的行为”修改成“提交原始字符串”。
基本完成了。不过如果没有配置字体，会导致 emoji 显示空白。可以参考我的字体方案来解决问题。
如果想要让 fcitx5 符合 breeze 的外观，可以安装这个包：fcitx5-breeze，然后在输入法 - 配置附加组件 - 经典用户界面 - 主题里面修改成 KDE Plasma 来实现。

Locale 设置
#

默认在安装的时候大家都会选择en_US.UTF-8，这是为了避免 tty 不支持中文显示。不过在安装完毕后，一般都会重新编译zh_CN.UTF-8的语言支持。

这里我选用了一些特殊的设置方式，而不是直接设置LC_ALL。原因是让各种工具提示的信息和显示的日志为英文，同时让单位之类的显示符合国内的习惯。

配置像这样：

# /etc/locale.conf
LANG=zh_CN.UTF-8 # 默认界面语言为中文
LC_MESSAGES=en_US.UTF-8 # 强制日志和错误信息用英文
LC_PAPER=en_SG.UTF-8 # 纸张尺寸 A4
LC_MEASUREMENT=en_SG.UTF-8 # 公制单位（米、升、℃）
LC_TIME=en_SG.UTF-8 # 24 小时制时间

参考archwikicn-安装教程

对 chromebook 的折腾过程
#

声音驱动
#

众所周知，Chromebook 很多型号的声音驱动一直是个大问题，windows 上面甚至得付费才有驱动，而我装好一进来也是没有声音的。

很幸运的，在 Chrultrabook 上面提示 Linux 是完全支持的。然后我就找到了这个项目：

WeirdTreeThing/chromebook-linux-audio

Script that enables audio support on many Chrome devices running various Linux distros

Python

494

直接一键部署，太舒服了！不过似乎不支持 Ubuntu。

后来，在 alsa 的一次更新后，我的喇叭不出声了，翻了下 issue，这里提到重新安装加上这个参数就可以了：

./setup-audio --branch syntax-7

按键映射
#

Chromebook 的键盘比较特殊，没有Del，没有Ins。原来Capslock的位置现在变成了Meta(Win) 键。而左Alt和Ctrl就变得非常大。

写声音脚本的这位兄弟顺手写了个按键映射：

WeirdTreeThing/cros-keyboard-map

Utility to generate keyd configurations for use on Chromebooks

Python

120

这个工具映射了上面的功能按键，让Meta+功能键可以实现原来的功能，然后单独按下功能键就是F1-F10。调节键盘背光，则是按下leftAlt+亮度按键。

我手动对这台笔记本的按键进行定制：

让锁屏按键变成Del
rightAlt加上锁屏按键变成F11，加上Backspace变成F12
删除了一些冗余的配置，避免了之前为了通用一刀切导致的物理音量键变成F8/F9的 bug

[ids]
k:0001:0001

[main]
f13=delete
rightalt = layer(rightalt)

[meta]
f1 = back
f2 = forward
f3 = refresh
f4 = f11
f5 = scale
f6 = brightnessdown
f7 = brightnessup
f8 = mute
f9 = volumedown
f10 = volumeup
backspace = f12

[alt]
f6 = kbdillumdown
f7 = kbdillumup

[rightalt]
f6 = kbdillumdown
f7 = kbdillumup
backspace = f12
f13 = f11

[control+alt]
f13 = C-A-delete

另外值得一提的就是，键盘上面所有的英文全部都是小写的。

充电
#

充电限制
#

首先需要安装 ectool，这一个工具可以在 aur 的fw-ectool-git下载，fw 代表的是 framework book，这个笔记本使用的是开源的 ec，正好 chromebook 也是这个，所以可以通用。

ectool 可以控制系统的充电情况。不过可惜我这一台是 10 代的，不支持 sustainer，也就是说 ec 不能实现在某个区间自动断电。所以只能写一个脚本来控制系统的充电情况。尽管这样还是有一些限制，比如说关机充电可能就会充到满。

接下来我会对我使用的一些脚本进行解释。

charge_control.sh：这是主要进行控制的脚本，里面有两个功能，一个是--check-battery，这个参数会检测电池电量，如果超过了 78，就会自动设置成 idle 模式，同时关闭计时器，避免进行无谓的计时；另一个是--connect-charger，这个用于 udev 的控制。
check-battery.service(timer)：尝试一下 systemd-timer，为后续的启动和停用计时器做准备。
control_systemd_battery_timer.sh：这是一个用于设置上述服务的脚本。主要是用于给 udev 触发使用。(在 rules 里面写这么多太不优雅了)
99-battery.rules：这就是 udev 触发的规则了。在插上电源的时候检测一次电池电量，大于 78 就 idle，小于就开始充电。同时开启计时器，每三分钟检测一次电池。如果拔掉电源，那么就停止计时器。

值得小心的是，需要把 service 设置成 enabled，这样当电量达到 78，同时插着电源并开启 idle 模式的时候重启电脑，才会保持这个电量，因为重启会重置限制充电的状态；同时也把 timer 设置成 enabled，这样在电池没到 78，同时冲着电的时候重启电脑，才能在到达 78 的时候检测到从而开启 idle 模式。

写了那么多，看起来还是有点臃肿的感觉！不过功能总算是实现了。

缓解 kde 的电量显示的 bug
#

我到手没几天，就发现 kde 报告的电池状态有 bug。当拔下充电器后，显示已连接充电器，但仍在放电。短暂插入充电器然后拔出，会有概率避免这个问题；睡眠再唤醒也能避免这个问题。

经过一系列的排查，发现问题出现在upower上，upower 报告了错误的电池状态。power_supply总共有三个对象：

AC
CROS_USBPD_CHARGER0
CROS_USBPD_CHARGER1

虽然在 sysfs 里面报告的online状态是正确的，来到upower就不对了。AC online的状态和充电器的状态是相反的。重启upower服务可以让状态正确，但是已经被powerdevil接收了，所以无济于事。我寻找了很多办法，最终在upower的 gitlab 上面的issue看到了解决方案：

覆写upower的 systemd 服务，把它访问 AC 的 sysfs 禁用：

### Editing /etc/systemd/system/upower.service.d/override.conf
### Anything between here and the comment below will become the contents of the drop-in file

[Service]
InaccessiblePaths=/sys/class/power_supply/AC /sys/devices/pci0000:00/0000:00:1f.0/PNP0C09:00/ACPI0003:00/power_supply/AC

### Edits below this comment will be discarded

虽然方法很暴力，但是它有效啊！

风扇控制
#

理论上，其他的 chromebook 可以直接通过 aur 安装fw-fanctrl来安装一个用 python 写的脚本来控制。

不过我这台 spin713 比较特殊，使用ectool来查看温度是这样的：

$ sudo ectool temps all
--sensor name -------- temperature -------- ratio (fan_off and fan_max) --
Temp1 318 K (= 45 C) 66% (298 K and 328 K)
Temp2 324 K (= 51 C) 86% (298 K and 328 K)
Temp3 314 K (= 41 C) N/A (fan_off=0 K, fan_max=0 K)

而lm-sensors的输出：

$ sensors |sed -n "/coretemp-/,/Temp3/p"

coretemp-isa-0000
Adapter: ISA adapter
Package id 0: +76.0°C (high = +100.0°C, crit = +100.0°C)
Core 0: +59.0°C (high = +100.0°C, crit = +100.0°C)
Core 1: +76.0°C (high = +100.0°C, crit = +100.0°C)
Core 2: +57.0°C (high = +100.0°C, crit = +100.0°C)
Core 3: +61.0°C (high = +100.0°C, crit = +100.0°C)

cros_ec-isa-0000
Adapter: ISA adapter
fan1: 1641 RPM
Temp1: +42.9°C
Temp2: +43.9°C
Temp3: +39.9°C

可以发现，ectool 并没有读取到 cpu 的温度，而是其他部分的温度，这个温度会比 cpu 负载高的时候的温度低很多，当 cpu 温度降下来后，又会比 cpu 温度高。而fw-fanctrl默认是取ectool里面最高的温度，这就会导致风扇控制不灵敏，~~目前办法还在想…~~

已经找到解决办法了：安装旧版的fw-fanctrl。在 24 年 5 月之后，这个工具读取温度的数据源从lm-sensors切换到了ectool，原因是他们认为这样更加准确。但是我的本子 ectool 无法读取到 cpu 的温度，用着旧版就可以了。

小结..
#

Arch 确实不算是一个能让人省心的系统，但是折腾的过程还是回味无穷的，paru 和 aur 配合在一起的包管理也非常好用。另外折腾的东西，等到以后再补充吧。

站点日志

Wed, 28 Feb 2024 00:00:00 +0000

2024.02.28

终于，我成功迁移到了 Hugo。听说性能不错，但是真没有很多东西写来着…
2025.3.31

从 blowfish 切换到了 stack 这个主题。用的人多，也可以抄别人的前端作业。

~~真的是因为不会改主题才半摆烂状态的！~~

参考了以下文章修改了主题，在此感谢：
1. Hugo Stack 魔改美化 | Naive Koala
2. Hugo Stack 主题添加「最后修改于」 - Shitao Wu | 吴诗涛
2025.6.16

突然心血来潮想弄博客！~~（才不是换了新轴体想打字了呢）~~

工欲善其事，必先利其器，又重新装修了一遍，这会又换回了blowfish。

感谢强大的gemini让我有机会写前端配好了友链，不久会写一篇文章讲讲我的过程~

Android Shell 中的命令：settings

Wed, 05 Apr 2023 00:00:00 +0000

前言
#

家里的创维盒子需要手机遥控功能，虽说百变遥控可以通过 root 实现，但是毕竟是十年前的老软件了，随着手机系统更新已经落伍了，但是一众新软件都是通过无障碍实现的鼠标和键盘输入，对于没有原生设置的电视，要如何解决呢？小米 6 的 20.1.16 版本 miui 有个大 bug:处于底部的通知栏磁贴怎么都拖不上去，就只能放弃不用了吗？

但是需要注意的是，修改所有的secure命名空间下面的设置项都需要 root 权限。

简单上手
#

原理介绍
#

现代 Android（7+）的设置项本质是修改/data/system/users/0/下的 settings_global.xml``settings_secure.xml``settings_system.xml 三个 xml，这三个文件保存了你在设置 app 里修改的项目。而旧版的 android 则是在“设置存储（com.android.providers.settings”里的/databases 里存储设置项目，查了下资料，大概说是因为效率原因？

使用方法
#

我们使用的时候，先列出可以修改的项目及参数： settings list <命名空间>
对某一设置项进行查看： settings get <命名空间> <项目>
对某一设置项进行修改： settings put <命名空间> <项目> <参数>

实操
#

使用 settings list 输出的内容大概可以粗略分为两种：

只能开启或者禁用的。1 为开启，0 为禁用。
有应用程序特定名字的项目。这些一般反编译 AndroidManifest.xml 会看到应用程序的声明，但由于不会用/和。分开实用性并不大。
要进行修改，得先知道它们的名字。既然我们要在这台设备上修改，那用另一台设备手动开启后就可以 list 出来，从而知道特定的名称。
需要注意的一点是，我们一般只是在原有的参数上面添加，所以在使用 settings put 时，别忘了把原有的参数也加上去。

首先当然是启用无障碍的总开关：
settings put secure accessibility_enabled 1

以下是我使用的一些常用应用对应的名称：

旋转的无障碍“旋转”的无障碍权限

settings put secure enabled_accessibility_services personal.fameit.nl.eg/nl.fameit.rotate.RotateAccessibilityService

KDE Connect 的鼠标控制

settings put secure enabled_accessibility_services org.kde.kdeconnect_tp/org.kde.kdeconnect.Plugins.MouseReceiverPlugin.MouseReceiverService

KDE Connect 的通知使用权:

settings put enabled_accessibility_services org.kde.kdeconnect_tp/org.kde.kdeconnect.Plugins.NotificationsPlugin.NotificationReceiver

settings put enabled_accessibility_services org.kde.kdeconnect_tp/org.kde.kdeconnect.Plugins.NotificationsPlugin.NotificationReceiver

KDE Connect 中启用的键盘

settings put secure enabled_input_methods org.kde.kdeconnect_tp/org.kde.kdeconnect.Plugins.RemoteKeyboardPlugin.RemoteKeyboardService

通知栏磁贴
按需添加，有一个叫做 system_qs_tiles 的项目，修改那个似乎没用。

settings put secure sysui_qs_tiles "airplane,cell,wifi,rotation,custom(com.v2ray.ang/.service.QSTileService),batterysaver,hotspot,mute,nfc,custom(net.dinglisch.android.taskerm/.QSTileService0),gps,edit "

结语
#

折腾了那么多，不得不感叹命令行的强大之处：正确就是 stout，错误就是 sterr，不会像 gui 控制那样出现卡顿和按了不反应等奇奇怪怪的 bug，当今时代 cli 还是有存在的意义的。

文章 on T.本秋的自留地

简单了解和手动使用 TPM

tpm 的相关属性 #

第一组：永久属性组 (PT -> Property) #

第二组：启动时状态 #

第三组：句柄资源 (HR -> Handle Resource) #

第四组：锁定相关配置 #

第五组：杂项 #

不同层级 #

初始化自己的 tpm 配置 #

开始使用 #

加密文字 #

验证签名 #

整活 #

polkit #

彩蛋 #

UPS 折腾记

前言 #

NUT 的配置 #

驱动层 #

服务层 #

客户端/监视层 #

关机过程 #

常用命令 #

upscmd：执行一些驱动预设的指令 #

upsrw：用于读写 eeprom 的 #

奇怪的 bug #

Immortalwrt：多线多网与 Tailscale

配置多线多内网 #

tailscale 出现的问题 #

Dbus 探索

前言 #

概念 #

命令行使用 #

自省 #

调用方法 #

属性 #

签名 #

简单的电量检测小工具 #

现代 C++ 笔记：I/O 流与字符串流

流 #

std::cin >> #

C-style 的函数 #

现代 C++ 笔记：继承、虚函数与异常处理

继承，派生 #

继承初始化 #

修改派生类的访问权限 #

访问修饰符 #

using来强制改变单个成员 #

隐藏功能 #

删除功能 #

虚函数 #

覆盖 #

协变返回类型 #

虚析构函数 #

绑定和调度 #

纯虚函数，纯虚类，虚基类 #

切片 #

RTTI #

dynamic_cast #

typeid #

委派重载函数 #

异常处理 #

异常对象的存储机制 #

在 catch 中抛出异常 #

函数级异常 #

noexcept #

std::move_if_noexcept #

Linux Swap：ZRAM、ZSWAP 与内存策略

引子 #

把内存变小，而不是放到低速存储上面 #

ZRAM #

存到极限 #

1. ZRAM 达到了设置的压缩前的数据的最大值。 #

2. ZRAM 还没满，但是物理内存就要满了 #

ZSWAP #

如何选择 #

桌面环境 #

其他环境 #

观察 #

tpm 的相关属性
#

第一组：永久属性组 (PT -> Property)
#

第二组：启动时状态
#

第三组：句柄资源 (HR -> Handle Resource)
#

第四组：锁定相关配置
#

第五组：杂项
#

不同层级
#

初始化自己的 tpm 配置
#

开始使用
#

加密文字
#

验证签名
#

整活
#

polkit
#

彩蛋
#

前言
#

NUT 的配置
#

驱动层
#

服务层
#

客户端/监视层
#

关机过程
#

常用命令
#

upscmd：执行一些驱动预设的指令
#

upsrw：用于读写 eeprom 的
#

奇怪的 bug
#

配置多线多内网
#

tailscale 出现的问题
#

前言
#

概念
#

命令行使用
#

自省
#

调用方法
#

属性
#

签名
#

简单的电量检测小工具
#

流
#

`std::cin >>`
#

C-style 的函数
#

继承，派生
#

继承初始化
#

修改派生类的访问权限
#

访问修饰符
#

`using`来强制改变单个成员
#

隐藏功能
#

删除功能
#

虚函数
#

覆盖
#

协变返回类型
#

虚析构函数
#

绑定和调度
#

纯虚函数，纯虚类，虚基类
#

切片
#

RTTI
#

`dynamic_cast`
#

`typeid`
#

委派重载函数
#

异常处理
#

异常对象的存储机制
#

在 `catch` 中抛出异常
#

函数级异常
#

`noexcept`
#

`std::move_if_noexcept`
#

引子
#

把内存变小，而不是放到低速存储上面
#

ZRAM
#

存到极限
#

1. `ZRAM` 达到了设置的压缩前的数据的最大值。
#

2. `ZRAM` 还没满，但是物理内存就要满了
#

ZSWAP
#

如何选择
#

桌面环境
#

其他环境
#

观察
#

参考
#

左右值、`&&`、移动语义、智能指针
#

类型 (Type)
#

值类别 (Value Category)
#

`&&`/`&` 作为函数形参
#

`&&` 在模板参数的使用
#

实现移动
#

智能指针
#