Logs on Zhiim's Blog

Linux 透明代理（TPROXY）配置

Wed, 22 Apr 2026 09:54:55 +0800

现代代理客户端（例如 sing-box 和 mihomo）已经支持非常精细而成熟的分流规则，我们完全可以使用全局透明代理实现最优的代理体验，而不用担心直连域名误走代理出站。

在 Linux 平台全局透明代理主要有基于内核防火墙的 iptables 模式和基于虚拟网卡的 TUN 模式。TUN 模式将原始的 IP 数据包拦截到虚拟网卡，代理软件需要运行一套完整的 TCP/IP 协议栈（如 gVisor）模拟 TCP 握手和状态机，开销极大。基于 iptables 的透明代理只需要通过内核态的 iptables 规则拦截内核处理好的 TCP 数据流并转交给代理软件，更加干净高效，此外 iptables 可以实现非常精细的拦截，例如放行 Tailscale 的流量。

正因如此，本文将介绍基于 iptables 的透明代理，针对 sing-box 与 mihomo 不同的 DNS 处理设置了对应的规则，并添加了放行 Tailscale 流量的配置。

iptables 简介

iptables 是 Linux 内核 Netfilter 防火墙的用户态配置工具，可以通过一套规则化的表达配置 Linux 内核防火墙的工作链路。iptables 规则由 Tables-Chains-Rules-Target 构成

Tables（表）：将规则按照功能放在不同的表中，默认包含 Filter（决定哪些数据包可以出入）、NAT（修改数据包的目标和源 IP 以及端口号）、Mangle（修改数据包的 IP 报头信息）、Raw（让特定流量不被内核追踪）
Chains（链）：数据包在系统中会依次经过不同的链，默认有 PREROUTING、INPUT、FORWARD、OUTPUT 和 POSTROUTING
Rules（规则）：匹配数据包的条件，例如源 IP 地址为 127.0.0.0 的 udp 数据包可以被匹配
Targets（动作）：数据包被匹配后执行的动作，例如 ACCEPT、DROP、REDIRECT

Netfilter 数据处理流程图

图中画出了数据包从入站到出站在 Netfilter 中依次经过的链和表，我们可以由三种场景窥探数据流向：

路由器中来自局域网设备访问互联网的流量，它们的目的 IP 是局域网外，所以会被路由器转发，流向：PREROUTING -> FORWARD -> POSTROUTING
来自其他设备的入站流量，由 INPUT 链中的 filter 表规则决定是否可以入站（例如 SSH 登录），流向：PREROUTING -> INPUT -> 本机
本机产生的发往外站的流量，由 OUTPUT 链中的 filter 表规则决定是否放行，流向：本机 -> OUTPUT -> POSTROUTING

标准的 iptables 命令通常包含了要操作的链、匹配条件以及执行的动作。例如，最基础的服务放行配置：

1
2
3
4
5
6
7
8
9


# 允许本地回环接口 (loopback) 的所有流量
iptables -A INPUT -i lo -j ACCEPT

# 允许目标端口为 80 (HTTP) 和 22 (SSH) 的 TCP 流量入站
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 将特定 IP 来源的流量直接丢弃且不产生回应
iptables -A INPUT -s 192.168.1.100 -j DROP

基于 iptables 实现透明代理

本节我们基于 iptables 实现透明代理：通过 iptables 规则将系统中的网络流量劫持并转发到代理客户端，然后经过代理客户端打包后发出。假设代理客户端（可以是 sing-box 或 mihomo）的 tproxy 入站端口设置为 9898。

劫持流量到代理客户端

Linux 透明代理可以使用 TPROXY 模块，它能完美处理 TCP 与 UDP 流量并保留真实源 IP，但是 TPROXY 模块只能挂载在 mangle 表的 PREROUTING 链。

局域网设备访问互联网的流量链路为 PREROUTING -> FORWARD -> POSTROUTING，只需要将 PREROUTING 链上的流量劫持到代理客户端的 tproxy 入站端口，就能实现流量被代理客户端转发。

设备自身产生的访问互联网的流量链路为 本机 -> OUTPUT -> POSTROUTING，并不会经过 PREROUTING 链。为了实现本机流量也走代理，可以将 OUTPUT 链的流量由回环设备 lo 发出，这样会自动被 lo 再次接受，流量就像外来包一样重新入站走 PREROUTING -> INPUT -> 本机，下一站就是 PREROUTING 链，之后被劫持到代理客户端的 tproxy 端口。

所以我们的透明代理分为两个步骤实现：

将 OUTPUT 链的流量由本地回环设备 lo 发出，让流量自动出现在 PREROUTING 链；
劫持 PREROUTING 链并转发到代理客户端。

将 OUTPUT 链的流量发往 lo 设备

在处理 OUTPUT 链流量时，需要放行由代理客户端发出的出站流量，否则流量会再次转发出现回环。为了解决这个问题，我们需要专门创建一个例如 tproxy 用户用于运行代理客户端，并且在 iptables 规则中放行 tproxy 用于发出的流量。

1
2
3
4


# 创建 tproxy 用户
sudo useradd -r -M -s /usr/sbin/nologin tproxy
# 调整权限，让代理客户端的配置文件属于 tproxy 用户
sudo chown -R tproxy:tproxy /usr/local/share/sing-box

创建 systemd 服务用于运行代理客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


[Unit]
Description=sing-box Service
After=network-online.target

[Service]
ExecStartPre=+/usr/sbin/setcap 'cap_net_admin,cap_net_bind_service,cap_net_raw,cap_sys_ptrace,cap_dac_read_search+ep' /usr/local/bin/sing-box
ExecStart=/usr/local/bin/sing-box run -c /usr/local/share/sing-box/config.json
WorkingDirectory=/usr/local/share/sing-box
RestartSec=3
User=tproxy
Group=tproxy

[Install]
WantedBy=multi-user.target

接下来，新建策略路由，将所有带有标签 1 的流量由 lo 设备发出。然后新建一个 TRANS_PROXY_MASK 链，将所有经过 TRANS_PROXY 链的流量打上标签 1，这样这些流量会自动由 lo 设备发出。最后只需要将不属于 tproxy 用户的出站流量由 OUTPUT 链劫持到 TRANS_PROXY_MASK 链。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# mask 被标记为 1 的数据包查询编号为 100 的路由表
ip rule add fwmark 1 table 100
# 在 100 路由表中将来源与任何 IP 的数据包标记为本地流量，并发由 lo 设备发出
ip route add local 0.0.0.0/0 dev lo table 100

# 创建 TRANS_PROXY_MASK 链
iptables -t mangle -N TRANS_PROXY_MASK
# 为 TRANS_PROXY_MASK 链中的流量打上 mask 1 实现劫持到 lo 设备
iptables -t mangle -A TRANS_PROXY_MASK -p tcp -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -p udp -j MARK --set-mark 1

# 劫持非 tproxy 用户的 OUTPUT 流量到 TRANS_PROXY_MASK 链
iptables -t mangle -A OUTPUT -m owner ! --uid-owner tproxy -j TRANS_PROXY_MASK

劫持 PREROUTING 链流量到代理客户端

新建一个 TRANS_PROXY 链，将经过 PREROUTING 链的流量拦截到 TRANS_PROXY 链，然后让经过 TRANS_PROXY 的所有 tcp 和 udp 流量发往透明代理的监听端口。

1
2
3
4
5
6
7
8
9


# 创建 TRANS_PROXY 链
iptables -t mangle -N TRANS_PROXY

# 将 tcp 和 udp 流量转发到 TRANS_PROXY，并且打上 mask 1 作为本地流量
iptables -t mangle -A TRANS_PROXY -p udp -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -p tcp -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1

# 劫持 PREROUTING
iptables -t mangle -A PREROUTING -j TRANS_PROXY

这里将流量发向 TRANS_PROXY 同样打上了标签 1，这是因为 PREROUTING 的下一步是根据目的 IP 判断走 FORWARD 链发往外部，还是走 INPUT 发往本地服务。打上标签 1 后会被策略路由看作 local 流量走 INPUT 发往本地的 9898 端口被代理客户端处理。

精细化放行

在上述路由转发规则的基础上，我们还需要设置放行规则，防止错误拦截。例如目的 IP 为同局域网设备的流量、Tailscale 的出入站流量不应该被拦截到代理客户端。

为了放行目的 IP 为同局域网设备的流量，可以在 TRANS_PROXY_MASK 和 TRANS_PROXY 链的最前端（规则是由前往后匹配的，所以这些规则需要最先添加）添加放行的规则。

1
2
3
4
5
6


iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 224.0.0.0/4 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 255.255.255.255/32 -j RETURN

1
2
3
4
5
6


iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 224.0.0.0/4 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 255.255.255.255/32 -j RETURN

Tailscale 组网设备的 IP 段为 100.64.0.0/10，并且 Tailscale 发出的流量会被打上标签 0x40000，Tailscale 入站的流量会由 tailscale0 设备接收。基于这些特征，我们可以添加规则不拦截 Tailscale 出入站的流量（同样需要在对应链中优先添加）。

1
2
3
4
5
6
7
8


# 本机发出的目的地址为 tailscale IP 段的流量绕过
iptables -t mangle -I TRANS_PROXY_MASK 1 -d 100.64.0.0/10 -j RETURN
# 本机发出的由 tailscale 产生的流量绕过
iptables -t mangle -I TRANS_PROXY_MASK 2 -m mark --mark 0x40000 -j RETURN
# 从 tailscale0 进入本机的流量绕过
iptables -t mangle -I TRANS_PROXY 1 -i tailscale0 -j RETURN
# 目的地址为 tailscale IP 段的流量绕过
iptables -t mangle -I TRANS_PROXY 2 -d 100.64.0.0/10 -j RETURN

劫持 DNS 流量

如果想要按照代理客户端的 DNS 规则解析域名，需要将系统的 DNS 请求也劫持到代理客户端。

DNS 请求劫持到 sing-box

sing-box 会将 DNS 流量和 TCP/UDP 流量一起处理，只要在 sing-box 的 route 字段添加

1
2
3
4


{
 "action": "hijack-dns",
 "protocol": "dns"
}

我们已经拦截了所有出站的 TCP/UDP 流量，所以如果系统设置了公共 DNS 服务器，sing-box 已经可以正常劫持 DNS 请求。如果系统的 DNS 服务器设置为上游网关，由于前面添加了放行目的 IP 为局域网 IP 的规则，需要额外劫持这些 IP 发往 53 端口的 TCP/UDP 流量。在 TRANS_PROXY_MASK 和 TRANS_PROXY 链的最前端添加

1
2
3
4
5
6


iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -p udp --dport 53 -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -p tcp --dport 53 -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -p udp --dport 53 -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -p tcp --dport 53 -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -p udp --dport 53 -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -p tcp --dport 53 -j MARK --set-mark 1

1
2
3
4
5
6


iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1

DNS 请求劫持到 mihomo

mihomo 同样可以在分流的时候将所有的 53 端口流量劫持到 DNS，但也提供了将 DNS 服务监听在特定端口的功能，实现代理流量和 DNS 流量的分离。本节将基于这一特性，假设 mihomo 的 DNS 服务监听在特定端口（例如 1053），通过 iptables 劫持 DNS 请求

1
2
3


dns:
 enable: true
 listen: 0.0.0.0:1053

想要使用 mihomo 的 DNS 服务，需要将发往 53 端口的 TCP/UDP 流量劫持为发往 127.0.0.1 的 1053 端口。由于 NAT 表控制了数据包的目的 IP 和端口，需要在 NAT 表上添加 iptables 规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 劫持 dns 流量到 mihomo
iptables -t nat -N MIHOMO_DNS
# 将目标为 53 端口的流量重定向到 mihomo 的 DNS 端口
iptables -t nat -A MIHOMO_DNS -p udp --dport 53 -j REDIRECT --to-ports 1053
iptables -t nat -A MIHOMO_DNS -p tcp --dport 53 -j REDIRECT --to-ports 1053

# 拦截本机的 DNS 请求
iptables -t nat -A OUTPUT -p udp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS
iptables -t nat -A OUTPUT -p tcp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS
# 拦截局域网设备的 DNS 请求
iptables -t nat -A PREROUTING -p udp --dport 53 -j MIHOMO_DNS
iptables -t nat -A PREROUTING -p tcp --dport 53 -j MIHOMO_DNS

总结

将上述所有规则放在一次，为了实现透明代理，我们需要一次执行的所有规则为

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


sysctl -w net.ipv4.ip_forward=1

# 添加策略路由将标签为 1 的流量看作本地流量并由 lo 本地回环设备发出
ip rule add fwmark 1 table 100
ip route add local 0.0.0.0/0 dev lo table 100

# 添加 TRANS_PROXY_MASK 链
iptables -t mangle -N TRANS_PROXY_MASK
# 放行 Tailscale 入站
iptables -t mangle -I TRANS_PROXY_MASK 1 -d 100.64.0.0/10 -j RETURN
iptables -t mangle -I TRANS_PROXY_MASK 2 -m mark --mark 0x40000 -j RETURN
# 如果劫持 DNS 请求到 sing-box
# iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -p udp --dport 53 -j MARK --set-mark 1
# iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -p tcp --dport 53 -j MARK --set-mark 1
# iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -p udp --dport 53 -j MARK --set-mark 1
# iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -p tcp --dport 53 -j MARK --set-mark 1
# iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -p udp --dport 53 -j MARK --set-mark 1
# iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -p tcp --dport 53 -j MARK --set-mark 1
# 放行目的 IP 为局域网 IP 的流量
iptables -t mangle -A TRANS_PROXY_MASK -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 224.0.0.0/4 -j RETURN
iptables -t mangle -A TRANS_PROXY_MASK -d 255.255.255.255/32 -j RETURN
# 给所有流经 TRANS_PROXY_MASK 链的流量打上标签 1
iptables -t mangle -A TRANS_PROXY_MASK -p tcp -j MARK --set-mark 1
iptables -t mangle -A TRANS_PROXY_MASK -p udp -j MARK --set-mark 1
# 将所有非 tproxy 用户发出的流量劫持到 TRANS_PROXY_MASK 链
iptables -t mangle -A OUTPUT -m owner ! --uid-owner tproxy -j TRANS_PROXY_MASK

# 添加 TRANS_PROXY 链
iptables -t mangle -N TRANS_PROXY
# 放行 Tailscale 出站
iptables -t mangle -I TRANS_PROXY 1 -i tailscale0 -j RETURN
iptables -t mangle -I TRANS_PROXY 2 -d 100.64.0.0/10 -j RETURN
# 如果劫持 DNS 请求到 sing-box
# iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# 放行目的 IP 为局域网 IP 的流量
iptables -t mangle -A TRANS_PROXY -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 224.0.0.0/4 -j RETURN
iptables -t mangle -A TRANS_PROXY -d 255.255.255.255/32 -j RETURN
# 将所有流经 TRANS_PROXY 链的流量发向代理客户端
iptables -t mangle -A TRANS_PROXY -p udp -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
iptables -t mangle -A TRANS_PROXY -p tcp -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# 将所有流经 PREROUTING 链的流量劫持到 TRANS_PROXY 链
iptables -t mangle -A PREROUTING -j TRANS_PROXY

# 如果劫持 DNS 请求到 mihomo
# iptables -t nat -N MIHOMO_DNS
# iptables -t nat -A MIHOMO_DNS -p udp --dport 53 -j REDIRECT --to-ports 1053
# iptables -t nat -A MIHOMO_DNS -p tcp --dport 53 -j REDIRECT --to-ports 1053
# iptables -t nat -A OUTPUT -p udp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS
# iptables -t nat -A OUTPUT -p tcp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS
# iptables -t nat -A PREROUTING -p udp --dport 53 -j MIHOMO_DNS
# iptables -t nat -A PREROUTING -p tcp --dport 53 -j MIHOMO_DNS

类似地，对于 IPV6 流量可以添加如下规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


sysctl -w net.ipv6.conf.all.forwarding=1

ip -6 rule add fwmark 1 table 101
ip -6 route add local ::/0 dev lo table 101

ip6tables -t mangle -N TRANS_PROXY_MASK6
ip6tables -t mangle -I TRANS_PROXY_MASK6 1 -d fd7a:115c:a1e0::/48 -j RETURN
ip6tables -t mangle -I TRANS_PROXY_MASK6 2 -m mark --mark 0x40000 -j RETURN
# 如果劫持 DNS 请求到 sing-box
# ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fe80::/10 -p udp --dport 53 -j MARK --set-mark 1
# ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fe80::/10 -p tcp --dport 53 -j MARK --set-mark 1
# ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fc00::/7 -p udp --dport 53 -j MARK --set-mark 1
# ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fc00::/7 -p tcp --dport 53 -j MARK --set-mark 1
ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fe80::/10 -j RETURN
ip6tables -t mangle -A TRANS_PROXY_MASK6 -d fc00::/7 -j RETURN
ip6tables -t mangle -A TRANS_PROXY_MASK6 -d ::1/128 -j RETURN
ip6tables -t mangle -A TRANS_PROXY_MASK6 -d ff00::/8 -j RETURN
ip6tables -t mangle -A TRANS_PROXY_MASK6 -p tcp -j MARK --set-mark 1
ip6tables -t mangle -A TRANS_PROXY_MASK6 -p udp -j MARK --set-mark 1
ip6tables -t mangle -A OUTPUT -m owner ! --uid-owner tproxy -j TRANS_PROXY_MASK6

ip6tables -t mangle -N TRANS_PROXY6
ip6tables -t mangle -I TRANS_PROXY6 1 -i tailscale0 -j RETURN
ip6tables -t mangle -I TRANS_PROXY6 2 -d fd7a:115c:a1e0::/48 -j RETURN
# 如果劫持 DNS 请求到 sing-box
# ip6tables -t mangle -A TRANS_PROXY6 -d fe80::/10 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# ip6tables -t mangle -A TRANS_PROXY6 -d fe80::/10 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# ip6tables -t mangle -A TRANS_PROXY6 -d fc00::/7 -p udp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
# ip6tables -t mangle -A TRANS_PROXY6 -d fc00::/7 -p tcp --dport 53 -j TPROXY --on-ip 127.0.0.1 --on-port 9898 --tproxy-mark 1
ip6tables -t mangle -A TRANS_PROXY6 -d fe80::/10 -j RETURN
ip6tables -t mangle -A TRANS_PROXY6 -d fc00::/7 -j RETURN
ip6tables -t mangle -A TRANS_PROXY6 -d ::1/128 -j RETURN
ip6tables -t mangle -A TRANS_PROXY6 -d ff00::/8 -j RETURN
ip6tables -t mangle -A TRANS_PROXY6 -p udp -j TPROXY --on-ip ::1 --on-port 9898 --tproxy-mark 1
ip6tables -t mangle -A TRANS_PROXY6 -p tcp -j TPROXY --on-ip ::1 --on-port 9898 --tproxy-mark 1
ip6tables -t mangle -A PREROUTING -j TRANS_PROXY6

# 如果劫持 DNS 请求到 mihomo
# ip6tables -t nat -N MIHOMO_DNS6
# ip6tables -t nat -A MIHOMO_DNS6 -p udp --dport 53 -j REDIRECT --to-ports 1053
# ip6tables -t nat -A MIHOMO_DNS6 -p tcp --dport 53 -j REDIRECT --to-ports 1053
# ip6tables -t nat -A OUTPUT -p udp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS6
# ip6tables -t nat -A OUTPUT -p tcp --dport 53 -m owner ! --uid-owner tproxy -j MIHOMO_DNS6
# ip6tables -t nat -A PREROUTING -p udp --dport 53 -j MIHOMO_DNS6
# ip6tables -t nat -A PREROUTING -p tcp --dport 53 -j MIHOMO_DNS6

清除规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


# 清理 IPv4 路由
ip rule del fwmark $FWMARK table $TABLE_V4 2>/dev/null || true
ip route del local 0.0.0.0/0 dev lo table $TABLE_V4 2>/dev/null || true

# 清理 IPv4 规则和链 (忽略不存在的错误)
iptables -t mangle -D PREROUTING -p tcp -m socket -j DIVERT 2>/dev/null || true
iptables -t mangle -F DIVERT 2>/dev/null || true
iptables -t mangle -X DIVERT 2>/dev/null || true

iptables -t mangle -D PREROUTING -j ${CHAIN_NAME} 2>/dev/null || true
iptables -t mangle -F ${CHAIN_NAME} 2>/dev/null || true
iptables -t mangle -X ${CHAIN_NAME} 2>/dev/null || true

iptables -t mangle -D OUTPUT -m owner ! --uid-owner $PROXY_USER -j ${CHAIN_NAME}_MASK 2>/dev/null || true
iptables -t mangle -F ${CHAIN_NAME}_MASK 2>/dev/null || true
iptables -t mangle -X ${CHAIN_NAME}_MASK 2>/dev/null || true

# 清理 mihomo DNS 规则
# iptables -t nat -D PREROUTING -p udp --dport 53 -j MIHOMO_DNS 2>/dev/null || true
# iptables -t nat -D PREROUTING -p tcp --dport 53 -j MIHOMO_DNS 2>/dev/null || true
# iptables -t nat -D OUTPUT -p udp --dport 53 -m owner ! --uid-owner $PROXY_USER -j MIHOMO_DNS 2>/dev/null || true
# iptables -t nat -D OUTPUT -p tcp --dport 53 -m owner ! --uid-owner $PROXY_USER -j MIHOMO_DNS 2>/dev/null || true
# iptables -t nat -F MIHOMO_DNS 2>/dev/null || true
# iptables -t nat -X MIHOMO_DNS 2>/dev/null || true

# 清理 IPv6 路由
ip -6 rule del fwmark $FWMARK table $TABLE_V6 2>/dev/null || true
ip -6 route del local ::/0 dev lo table $TABLE_V6 2>/dev/null || true

# 清理 IPv6 规则和链
ip6tables -t mangle -D PREROUTING -p tcp -m socket -j DIVERT6 2>/dev/null || true
ip6tables -t mangle -F DIVERT6 2>/dev/null || true
ip6tables -t mangle -X DIVERT6 2>/dev/null || true

ip6tables -t mangle -D PREROUTING -j ${CHAIN_NAME}6 2>/dev/null || true
ip6tables -t mangle -F ${CHAIN_NAME}6 2>/dev/null || true
ip6tables -t mangle -X ${CHAIN_NAME}6 2>/dev/null || true

ip6tables -t mangle -D OUTPUT -m owner ! --uid-owner $PROXY_USER -j ${CHAIN_NAME}_MASK6 2>/dev/null || true
ip6tables -t mangle -F ${CHAIN_NAME}_MASK6 2>/dev/null || true
ip6tables -t mangle -X ${CHAIN_NAME}_MASK6 2>/dev/null || true

# 清理 mihomo DNS 规则
# ip6tables -t nat -D PREROUTING -p udp --dport 53 -j MIHOMO_DNS6 2>/dev/null || true
# ip6tables -t nat -D PREROUTING -p tcp --dport 53 -j MIHOMO_DNS6 2>/dev/null || true
# ip6tables -t nat -D OUTPUT -p udp --dport 53 -m owner ! --uid-owner $PROXY_USER -j MIHOMO_DNS6 2>/dev/null || true
# ip6tables -t nat -D OUTPUT -p tcp --dport 53 -m owner ! --uid-owner $PROXY_USER -j MIHOMO_DNS6 2>/dev/null || true
# ip6tables -t nat -F MIHOMO_DNS6 2>/dev/null || true
# ip6tables -t nat -X MIHOMO_DNS6 2>/dev/null || true

更加便捷的应用和清除规则可以参考脚本。

Linux 桌面在非 TUN 模式下给 Antigravity 设置代理

Thu, 08 Jan 2026 10:04:27 +0800

Antigravity 是 Google 推出的 AI IDE，凭借慷慨的 AI 额度广受欢迎。然而在国内的网络环境下，目前使用 Antigravity 一般需要通过 Clash TUN 模式设置全局代理，这势必会对整个系统的网络造成负面影响。Windows、Mac 系统下如何不使用 TUN 模式实现 Antigravity 代理的方案，在 LINUX DO 等论坛已广为讨论。本文探究了在 Linux 桌面中，如何为 Antigravity 设置代理以在国内正常使用，而不使用 TUN 全局代理模式

Antigravity 的代理需要代理两个组件，一个是主体应用，一个是 language_server 进程。主体应用基于 VS Code 开发，使用 Electron 技术栈，可以通过传入启动参数设置代理；language_server 使用 Go 语言开发，不受启动参数和系统代理的影响，需要借助 graftcp 实现代理

主体应用代理

因为 Antigravity 是一个 electron 应用，我们可以通过启动参数在启动时为应用设定代理。为了每次启动应用时自动应用代理配置，可以修改 .desktop 启动文件

1
2


mkdir -p ~/.local/share/applications
cat /usr/bin/applications/antigravity.desktop > ~/.local/share/applications/antigravity.desktop

然后编辑 antigravity.desktop 设定启动参数，添加 --proxy-server=http://127.0.0.1:7890

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


[Desktop Entry]
Name=Antigravity
Comment=Experience liftoff
GenericName=Text Editor
Exec=/opt/Antigravity/antigravity --proxy-server=http://127.0.0.1:7890 %F
Icon=antigravity
Type=Application
StartupNotify=false
StartupWMClass=Antigravity
Categories=TextEditor;Development;IDE;
MimeType=application/x-antigravity-workspace;
Actions=new-empty-window;
Keywords=vscode;

[Desktop Action new-empty-window]
Name=New Empty Window
Name[cs]=Nové prázdné okno
Name[de]=Neues leeres Fenster
Name[es]=Nueva ventana vacía
Name[fr]=Nouvelle fenêtre vide
Name[it]=Nuova finestra vuota
Name[ja]=新しい空のウィンドウ
Name[ko]=새 빈 창
Name[ru]=Новое пустое окно
Name[zh_CN]=新建空窗口
Name[zh_TW]=開新空視窗
Exec=/opt/Antigravity/antigravity --new-window --proxy-server=http://127.0.0.1:7890 %F
Icon=antigravity

language_server 代理

虽然 Antigravity 的大部分组件都可以通过启动参数走代理，但是最重要的模型调用程序 language_server 是 Go 语言开发的，不受启动参数的影响，会导致模型加载不出来

此外 Go 语言程序没法用 proxychains 强制代理，参考解决远程linux服务器使用谷歌Antigravity反重力IDE登录问题，使用 graftcp 实现 language_server 代理

首先安装 graftcp，可以参考官方仓库安装，如果是 Arch 的话直接通过 AUR 安装

1

paru -S graftcp

找到 language_server 的路径

1

ps aux | grep ".*antigravity.*language_server" | grep -v grep

可以看到其中有一条类似

1

xu 2230564 0.0 0.0 2896 1928 ? S 11:37 0:00 /usr/bin/graftcp /opt/Antigravity/resources/app/extensions/antigravity/bin/language_server_linux_x64 --enable_lsp --extension_server_port 40671 --csrf_token d54fd753-5170-456b-99e0-7c191b58ce31 --random_port --workspace_id file_home_xu_Documents_codes_silverbullet --cloud_code_endpoint https://daily-cloudcode-pa.googleapis.com --app_data_dir antigravity --parent_pipe_path /tmp/server_c1a467ac4ea0e046

说明我的 language_server 在 /opt/Antigravity/resources/app/extensions/antigravity/bin 文件夹下

先将原始 language_server 程序备份

1
2
3
4


cd /opt/Antigravity/resources/app/extensions/antigravity/bin
sudo mv language_server_linux_x64 language_server_linux_x64.bak
sudo touch language_server_linux_x64
sudo chmod +x language_server_linux_x64

编辑刚刚创建的 language_server_linux_x64 文件，写入脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#!/bin/bash

# ================= 配置区域 =================
# 1. Graftcp 安装目录
GRAFTCP="/usr/bin/graftcp"
GRAFTCP_LOCAL="/usr/bin/graftcp-local"

# 2. 代理地址
PROXY_URL="127.0.0.1:7890"
# ===========================================

# 调试日志
LOG_FILE="/tmp/graftcp_wrapper.log"
echo "[$(date)] Starting wrapper for $@" >> "$LOG_FILE"

# 检查 graftcp-local 服务是否在运行
if ! pgrep -f "$GRAFTCP_LOCAL" > /dev/null; then
echo "Starting graftcp-local daemon..." >> "$LOG_FILE"
# 后台启动，将日志丢入黑洞防止阻塞
nohup "$GRAFTCP_LOCAL" -socks5="$PROXY_URL" > /dev/null 2>&1 &

sleep 0.5
fi
# 1. 强制使用系统 DNS (解决解析问题)
export GODEBUG=netdns=cgo

# 2. 强制关闭 HTTP/2 (解决 EOF 问题)
# Go 的 HTTP/2 客户端在代理环境下非常敏感，强制用 HTTP/1.1 通常能解决 EOF
export GODEBUG=$GODEBUG,http2client=0
# 使用 graftcp 启动真正的程序
# "$0.bak" 是原程序的备份
exec "$GRAFTCP" "$0.bak" "$@"

现在直接打开 Antigravity 就可以直接使用了

Linux Antigravity 残旧进程

目前 Antigravity 的 Linux 版本存在进程 bug （至少在 Arch Linux 如此），退出应用后还会存在大量未退出进程，需要使用一个 wrapper 脚本在退出时自动杀死所有 Antigravity 进程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#!/bin/bash

readonly UNIT_NAME="antigravity-$(date +%s)"

ARGS_ESCAPED=$(printf "%q " "$@")
readonly APP_BIN="/opt/Antigravity/antigravity --proxy-server=http://127.0.0.1:7890 --verbose $ARGS_ESCAPED"

readonly TRIGGER="Lifecycle#onWillShutdown - end 'antigravityAnalytics'"

echo "[*] Start as: $UNIT_NAME"

systemd-run --user \
 --scope \
 --unit="$UNIT_NAME" \
 --property=KillMode=control-group \
 /bin/bash -c "exec prlimit --core=0 ${APP_BIN} 2>&1 | systemd-cat --identifier=$UNIT_NAME" &

journalctl --user --identifier="$UNIT_NAME" --follow | \
 grep --line-buffered --max-count=1 "$TRIGGER" && \
 systemctl --user kill --signal=SIGKILL "$UNIT_NAME.scope"

echo "[*] Remaining processes are killed."

在 antigravity.desktop 里用脚本替换 Antigravity 的可执行文件即可。此脚本已经考虑了代理参数，所以在 antigravity.desktop 里可以一并移除代理参数设置

通过Github Copilot获取GPT-4 API

Mon, 12 Feb 2024 15:19:19 +0800

最近Github向GitHub Student Developer Pack添加了无限使用Github Copilot的权益，大大提升了学生包的价值，学生认证后即可免费体验这款强大的AI编程助手。Github Copilot的实际体验让人不得不感慨AI的强大，Copilot自动补全的代码大多数情况下可以直接使用，大大提升了编程效率；Copilot Chat也可以对各种编程问题提供非常有用的建议。

除此之外，由于Github Copilot的底层使用了GPT，我们也可以通过Copilot免费使用GPT-4。要实现这样的功能只需要使用开源项目copilot-gpt4-service获取GPT API，然后就可以通过GPT API搭配GPT前端来访问GPT-4，此外还可以使用GPT API部署AI学术助手gpt academic。

copilot-gpt4-service：通过Github Copilot Plugin Token调用GPT API。
chatbox：GPT前端，搭配GPT API可以搭建自己的ChatGPT，并和GPT-4对话。
gpt_academic：使用GPT API的AI学术助手，支持英文论文润色，一键翻译论文等功能。

获取GPT API

从Copilot获取GPT API只需要两步

运行copilot-gpt4-service得到一个API URL用来替代OpenAI的API URL
获取Github Copilot Plugin Token代替OpenAI的API Key

编译可执行文件

copilot-gpt4-service使用Go语言编写，官方未提供编译好的可执行文件，所以只能自己编译，需要下载并安装Go语言编译器，然后将源码下载到本地编译。

将copilot-gpt4-service克隆到本地

1

git clone https://github.com/aaamoon/copilot-gpt4-service.git

编译源码，得到一个名为main的可执行文件

1
2
3
4


# 进入项目目录
cd copilot-gpt4-service
# 编译
go build main.go

在终端中执行可执行文件，此时程序会打印出程序运行的端口以及可用的API地址

1

./main

选择本地IP对应的API的地址http://127.0.0.1:8080，在浏览器中打开，如果出现下方提示表示程序运行正常

Very important: please do not make this service public, for personal use only, otherwise the account or Copilot will be banned. 非常重要：请不要将此服务公开，仅供个人使用，否则账户或 Copilot 将被封禁。

获取Github Copilot Plugin Token

打开新的终端（如果关闭原本终端，正在运行的copilot-gpt4-service也会被关闭），运行Python脚本获取Github Copilot Plugin Token。

1
2
3
4


# 安装依赖库
pip install -r requests
# 运行脚本
python shells/get_copilot_token.py

根据终端输出的提示，在浏览器中打开Github验证页面，输入终端打印的认证码获取Github Copilot Plugin Token。

使用GPT前端

Chatbox是一款跨平台的GPT前端，可以使用GPT API搭建自己的ChatGPT，下载安装并填入GPT API的URL和Github Copilot Plugin Token即可使用。

下载并打开chatbox，进行如下设置：

AI模型提供方选择OpenAI API
OpenAI API 密钥填入上一步获取的Github Copilot Plugin Token
API 域名填入http://127.0.0.1:8080
模型选择gpt-4或者GPT的其他任意版本

为了验证API返回的结构是否来自GPT-4，可以提问鲁迅为什么暴打周树人，GPT-3.5会胡说八道，GPT-4会给出正确答案。

搭建GPT Academic

将项目克隆到本地，并进入项目目录

1
2


git clone https://github.com/binary-husky/gpt_academic.git
cd gpt_academic

安装依赖库

1

pip install -r requirements.txt

修改config.py中的下面几项

1
2
3
4
5
6
7


API_KEY = "ghu_xxxxx" # Github Copilot Plugin Token

API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "http://127.0.0.1:8080/v1/chat/completions"}

CUSTOM_API_KEY_PATTERN = "ghu_[a-zA-Z0-9]{36}"

WEB_PORT = 1234 # 固定端口，也可以为其他值

运行程序，程序会自动在浏览器打开GPT Academic的页面，同样可以通过提问验证API配置是否正常

1

python main.py

在Atlas 200 DK中部署深度学习模型

Tue, 26 Sep 2023 12:08:08 +0800

环境准备

本文部署的模型是使用TensorFlow2训练的ResNet网络，用于干扰信号识别，原本的模型文件将权重保存在ResNet.h5中。

从模型文件中读取权重，并使用测试数据进行推理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import ResNet as ResNet
import numpy as np

# 干扰类型
class_names = ['CSNJ', 'CW', 'LFM', 'MTJ', 'PBNJ', 'PPNJ']

# 权重文件的存储路径
model_path = "ResNet.h5"

data_dimension = (256, 256, 1)
model = ResNet.ResNet50(data_dimension)
# 导入网络模型
model.load_weights(model_path)

# 读取测试数据
test_img = np.load('test_img.npy')

# 转换输入数据的维度
test_img = np.array(test_img) # (256, 256)
test_img = np.expand_dims(test_img, axis=2) # (256, 256, 1)
test_img = np.expand_dims(test_img, 0) # (1, 256, 256, 1)

test_output = model.predict(test_img)

# 模型输出的干扰类型
pred = class_names[test_output.argmax()]
print(pred)

Atlas 200 DK的环境部署采用“开发环境与运行环境分设”的方案，开发环境使用Windows下Linux子系统中的Ubuntu 22.04.3 LTS，CANN版本为6.0.RC1.alpha005。

参考官方教程开发环境与运行环境分设完成环境配置。

cann-toolkit 配置

在Ubuntu中安装完Ascend-cann-toolkit后，运行模型转换工具atc时可能会出现报错

1

error while loading shared libraries: libascend_hal.so: cannot open shared object file: No such file or directory

这是由于无法找到库文件libascend_hal.so，此时可以进入Ascend-cann-toolkit的安装路径，寻找libascend_hal.so

1
2
3


xu@DESKTOP-9B4N33I:~$ cd Ascend/ascend-toolkit/latest/
xu@DESKTOP-9B4N33I:~/Ascend/ascend-toolkit/latest$ find . -name libascend_hal.so
./x86_64-linux/devlib/libascend_hal.so

将libascend_hal.so复制到任意路径，并将该路径添加到Ascend-cann-toolkit环境变量中的LD_LIBRARY_PATH。

例如将libascend_hal.so复制到~/Ascend/missing_lib

1
2


xu@DESKTOP-9B4N33I:~$ mkdir ~/Ascend/missing_lib
xu@DESKTOP-9B4N33I:~$ cp ~/Ascend/ascend-toolkit/latestx86_64-linux/devlib/libascend_hal.so ~/Ascend/missing_lib

在~/.bashrc中更改环境变量

1

export LD_LIBRARY_PATH=${ASCEND_TOOLKIT_HOME}/lib64:${ASCEND_TOOLKIT_HOME}/lib64/plugin/opskernel:${ASCEND_TOOLKIT_HOME}/lib64/plugin/nnengine:/home/xu/Ascend/missing_lib:$LD_LIBRARY_PATH

在终端输入source ~/.bashrc并重启终端，此时atc可以正常运行。

模型转换

由于TensorFlow2不再支持导出模型为FrozenGraphDef格式，而atc转换TensorFlow模型时只能使用FrozenGraphDef格式，所以本文采用的转换流程是，先将TensorFlow模型导出为SavedModel格式，再将模型转换为ONNX格式，最后使用atc将ONNX模型转换为.om格式。

将TensorFlow模型导出为SavedModel

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import tensorflow as tf
import ResNet as ResNet
import os

model_path = 'ResNet.h5' # 权重文件路径

data_dimension = (256, 256, 1)
model = ResNet.ResNet50(data_dimension)

# 读取网络模型
model.load_weights(model_path)

# export model to savedmodel
mobilenet_save_path = os.path.join("./model")
tf.saved_model.save(model, mobilenet_save_path)

将SavedModel转换为ONNX模型

使用tf2onnx将SavedModel转换为.onnx格式的模型。

1

python -m tf2onnx.convert --saved-model tensorflow-model-path --output model.onnx

由于atc不支持ONNX的高版本算子，转换时tf2onnx的–opset 参数值需使用默认值15。

导出的ONNX模型可以使用Netron查看网络结构。使用ONNX模型完成推理以验证模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import onnxruntime as onnxrt
import numpy as np

class_names = ['CSNJ', 'CW', 'LFM', 'MTJ', 'PBNJ', 'PPNJ']

# load model
model = onnxrt.InferenceSession("resnet.onnx",
 providers=['AzureExecutionProvider', 'CPUExecutionProvider'])
print("loading model success!")

# input data
test_img = np.load('test_img.npy')
test_img = np.array(test_img, dtype=np.float32) # (256, 256)
test_img = np.expand_dims(test_img, axis=2) # (256, 256, 1)
test_img = np.expand_dims(test_img, 0) # (1, 256, 256, 1)

# input
sf_input = {model.get_inputs()[0].name:test_img}

# output
output = model.run(None, sf_input)
print("get output of spatial filter success!")
output = np.array(output)

pred = class_names[output.argmax()]
print(pred)

将ONNX模型转换为om格式

`domain_version`报错

在Ubuntu终端中运行atc模型转换工具

1

atc --model=resnet.onnx --framework=5 --output=resnet --soc_version=Ascend310

可能会出现报错

1

E16005: The model has [2] [--domain_version] fields, but only one is allowed.

这是由于在将模型转换为ONNX是产生了两个(domain, version)（domain_version的概念参考ONNX Concepts）。

获取ONNX模型中的(domain,version)

1
2
3
4


import onnx

model = onnx.load("resnet.onnx")
print(model.opset_import)

得到输出

1
2
3
4
5


[domain: ""
version: 15
, domain: "ai.onnx.ml"
version: 2
]

此时只需去除多余的(domain,version)，保留一个即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import onnx

model = onnx.load("resnet.onnx")

# atc 模型转换只支持一个domain_version
if len(model.opset_import) > 1:
 # 删除多余的domain_version
 model.opset_import.pop()

# 将删除domain_version后的模型保存
onnx.save(model, "./resnet.onnx")

模型输入维度报错

再次运行atc，出现报错

1

E10001: Value [-1] for parameter [input_2] is invalid. Reason: maybe you should set input_shape to specify its shape.

使用Netron查看网络结构，发现input_2是输入节点，Netron中显示的该节点信息为

1
2


name: input_2
tensor: float32[unk__618,256,256,1]

输入数据为四维张量，每一个维度分别表示N（数量）H（高）W（宽）C（通道数），例如前面模型推理时使用的数据维度为(1, 256, 256, 1)表示1个高和宽都为256，通道数为1的图像。

在导出的ONNX模型中维度N的数值为指定，需要在模型转换时使用--input-shape参数指定输入节点的维度

1

atc --model=resnet.onnx --framework=5 --output=resnet --input-shape="input_2:1,256,256,1" --soc_version=Ascend310

在Atlas 200 DK中进行模型推理

模型推理时使用的是pyACL接口，并使用了第三库acllite。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


import numpy as np
import sys
import os

# 将acllite路径添加到python环境变量
path = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.join(path, ".."))
sys.path.append(os.path.join(path, "../../common"))
sys.path.append(os.path.join(path, "../../common/acllite"))

from acllite_model import AclLiteModel
from acllite_resource import AclLiteResource

MODEL_PATH = "../model/resnet.om"

# init
acl_resource = AclLiteResource()
acl_resource.init()
# load model
model = AclLiteModel(model_path=MODEL_PATH)

test_img = np.load("../data/test_img.npy")
test_img = np.array(test_img) # (256, 256)
test_img = np.expand_dims(test_img, axis=2) # (256, 256, 1)
test_img = np.expand_dims(test_img, 0) # (1, 256, 256, 1)
test_img = test_img.astype(np.float32)

# get output of model
output = model.execute(test_img)

output = np.squeeze(output)
print(output)

class_names = ['CSNJ', 'CW', 'LFM', 'MTJ', 'PBNJ', 'PPNJ']
pred = class_names[output.argmax()]
print(pred)

Arch Linux 配置 — Btrfs与系统备份

Tue, 11 Jul 2023 14:54:53 +0800

Btrfs

更据官方文档的说明

BTRFS is a modern copy on write (COW) filesystem for Linux aimed at implementing advanced features while also focusing on fault tolerance, repair and easy administration.

Btrfs拥有较多传统文件系统如Ext3/4不具有的高级功能，为我们日常文件系统使用和备份带来了便利。

写时复制（Copy-on-Write，CoW）

Btrfs默认采用CoW机制，将文件指针存放在metadata文件中。在对文件进行更改时，Btrfs会将新的数据写在新的空闲数据块中，数据写入完成后，更新metadata增加将文件指向新的内存块的指针。

子卷（subvolume）

一个子卷可以看作是Btrfs中的一个文件夹，但是子卷也可以像分区一样被挂载。例如在subvolume-test中创建一个子卷subvolume，就相当于创建了一个对应的文件夹。

1
2
3
4
5
6
7
8


❯ mkdir subvolume-test && cd subvolume-test
❯ sudo btrfs subvolume create subvolume # 创建子卷
Create subvolume './subvolume'
❯ ls -l
总计 0
drwxr-xr-x 1 root root 0 7月10日 17:19 subvolume # 当前目录出现对应的文件夹
❯ sudo btrfs subvolume list -o . # 查看当前目录下存在的子卷
ID 263 gen 6134 top level 257 path @home/xu/subvolume-test/subvolume

如果把子卷挂载到某一目录中，那么该目录内的内容就和该子卷相同了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


❯ mkdir mount-test # 创建挂载文件夹
❯ sudo mount -o subvol=@home/xu/subvolume-test/subvolume /dev/nvme0n1p6 mount-test
❯ sudo touch subvolume/test # 在子卷内新建文件
❯ tree .
.
├── mount-test
│   └── test # 挂载文件夹内容和子卷相同
└── subvolume
 └── test
3 directories, 2 files

Btrfs文件系统中默认会存在一个ID为5的根子卷，用户创建的子卷都是根子卷下的嵌套子卷。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


❯ mkdir rootsub
❯ sudo mount -o subvolid=5 /dev/nvme0n1p6 rootsub # 挂载根子卷
❯ ls rootsub
@ @home # 根子卷下包含的子卷
❯ df
文件系统 1K的块 已用 可用 已用% 挂载点
dev 3929540 0 3929540 0% /dev
run 3941308 1480 3939828 1% /run
/dev/nvme0n1p6 251133952 38761288 210874440 16% /
tmpfs 3941308 157696 3783612 5% /dev/shm
/dev/nvme0n1p6 251133952 38761288 210874440 16% /home
tmpfs 3941312 19428 3921884 1% /tmp
/dev/nvme0n1p8 523248 6172 517076 2% /efi
tmpfs 788260 76 788184 1% /run/user/1000
onedriver 1131413504 200908800 930504704 18% /home/xu/OneDrive
/dev/nvme0n1p6 251133952 38761288 210874440 16% /home/xu/rootsub

可以看到我的根子卷下创建了@子卷和@home子卷分别挂载在/和/home文件夹下。每一个子卷都可以达到文件系统的总容量，使用子卷挂载/和/home就免除了某一个分区空间不足的烦恼。

快照（snapshot）

快照可以看作是一个子卷，对一个子卷创建快照就是创建了一个新的子卷，这个新的子卷内容和原本子卷完全相同，但是快照不会包含子卷内的嵌套子卷。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


❯ mkdir snapshot-test && cd snapshot-test
❯ sudo btrfs subvolume create demo # 创建子卷demo
Create subvolume './demo'
❯ sudo touch demo/a demo/b
❯ sudo btrfs subvolume snapshot demo demo-snapshot # 创建子卷的快照
Create a snapshot of 'demo' in './demo-snapshot'
❯ tree
.
├── demo
│   ├── a
│   └── b
└── demo-snapshot # 快照和子卷具有相同的内容
 ├── a
 └── b

3 directories, 4 files

得益于CoW的特性，Btrfs创建快照时并不会将原子卷中的内容复制到快照子卷中，而是在快照中创建了指向原子卷内容的指针。如果对子卷内的文件进行更改，原本内容在数据块中不会改变，只是增加了指向新数据块的指针。

使用快照备份系统

得益于Btrfs的快照特性，我们可以快速方便地备份和回滚系统，而且系统快照只会占用很小的储存空间，在备份方案上，我选择使用Snapper创建和管理系统快照。

Snapper自动备份

首先安装Snapper

1

sudo pacman -S snapper

为挂载在/目录下的子卷创建命名为root的快照配置文件

1

sudo snapper -c root create-config /

此时Snapper会在/etc/snapper/configs生成配置文件，并且在根目录/挂载的子卷即@下创建.snapshots子卷，所有快照都会存储在.snapshots子卷下

1
2
3
4
5
6


❯ sudo btrfs subvolume list /
ID 256 gen 6803 top level 5 path @
ID 257 gen 6803 top level 5 path @home
ID 258 gen 17 top level 256 path var/lib/portables
ID 259 gen 18 top level 256 path var/lib/machines
ID 266 gen 6800 top level 256 path .snapshots # 挂载在@子卷下

Snapper可以自动创建和清除快照，默认会每小时创建一个快照，每天清理一次快照，在清理时会保存10个每小时快照、10个每日快照、10个每月快照、10个每年快照，但是对于日常使用更改较频繁的子卷我们不需要这么频繁的快照。

修改/lib/systemd/system/snapper-timeline.timer，设置每6小时创建一次快照

1
2
3
4
5
6
7
8
9


[Unit]
Description=Timeline of Snapper Snapshots
Documentation=man:snapper(8) man:snapper-configs(5)

[Timer]
OnCalendar=00/3:00 # 每3小时创建一次快照

[Install]
WantedBy=timers.target

修改配置文件/etc/snapper/configs/root中的变量，改变清理是保留的快照数量

1
2
3
4
5
6


TIMELINE_MIN_AGE="1800"
TIMELINE_LIMIT_HOURLY="3" # 保留3个小时快照
TIMELINE_LIMIT_DAILY="7" # 保留7个每日快照
TIMELINE_LIMIT_WEEKLY="0"
TIMELINE_LIMIT_MONTHLY="0"
TIMELINE_LIMIT_YEARLY="0"

开启Snapper自动快照和自动清理

1
2


sudo systemctl enable --now snapper-timeline.timer
sudo systemctl enable --now snapper-cleanup.timer

改变快照存储位置

Snapper默认把快照存储在@子卷内的.snapshots分卷下，如果@子卷损坏.snapshots也可能受影响，所以更好的子卷结构是把快照存储在@snapshots子卷下，然后把@snapshots挂载在根子卷下，这样@和@snapshots互不影响。

删除默认的.snapshots子卷

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


❯ sudo btrfs subvolume list /
ID 256 gen 7144 top level 5 path @
ID 257 gen 7144 top level 5 path @home
ID 258 gen 17 top level 256 path var/lib/portables
ID 259 gen 18 top level 256 path var/lib/machines
ID 266 gen 7115 top level 256 path .snapshots
ID 267 gen 6963 top level 266 path .snapshots/1/snapshot
ID 272 gen 6995 top level 266 path .snapshots/2/snapshot
# 如果已经有快照，需要先删除.snapshots里面的快照子卷
❯ sudo btrfs subvolume delete .snapshots/1/snapshot
Delete subvolume (no-commit): '/.snapshots/1/snapshot'
❯ sudo btrfs subvolume delete .snapshots/2/snapshot
Delete subvolume (no-commit): '/.snapshots/2/snapshot'
❯ sudo btrfs subvolume delete .snapshots
Delete subvolume (no-commit): '//.snapshots'

在根子卷下并列@子卷创建一个@snapshots子卷

1
2


sudo mount -o subvolid=5 /dev/nvme0n1p6 ~/rootsub # 挂载根子卷
sudo btrfs subvolume create ~/rootsub/@snapshots # 在根子卷下创建子卷

编辑/etc/fstab，将@subvolume子卷挂载到./snapshots

1
2


# 仿照@和@home子卷的挂载更改
UUID=d26ed334-68d4-481d-894f-838783fa4f88 /.snapshots btrfs rw,relatime,compress=zstd:3,ssd,discard=async,space_cache=v2,subvolid=275,subvol=/@snapshots 0 0

挂载@snapshots子卷

1
2
3


sudo mkdir /.snapshots
sudo mount -a
sudo chmod 750 /.snapshots # 阻止非root用户访问

Btrfs的快照不会备份其他子卷的内容，所以我们也可以把/var/cache/pacman/pkg、/var/abs、/var/tmp和/srv等经常读写但有没必要备份的文件夹挂载成子卷。

从快照中恢复

假设我们已经为/创建了快照，如果想要从快照中恢复系统，可以先进入Arch Linux live USB，然后挂载Btrfs分区

1
2


sudo mount /dev/nvme0n1p6 /mnt
cd /mnt

移除旧的@子卷

1

sudo mv /mnt/@ /mnt/@.broken

列出所有快照和对应的时间信息

1
2
3


$ sudo grep -r '<date>' /mnt/@snapshots/*/info.xml
/.snapshots/1/info.xml: <date>2023-07-11 06:21:53</date> # Snapper使用UTC时间记录快照创建时间
/.snapshots/2/info.xml: <date>2022-07-11 06:22:39</date>

由于Snapper创建的快照是只读子卷，所以需要从快照中创建可读写快照作为@子卷

1

sudo btrfs subvolume snapshot /mnt/@snapshots/{number}/snapshot /mnt/@

然后就可以删除旧的@子卷

1

sudo btrfs subvolume delete /mnt/@.broken

Reference

Arch Linux 配置 -- 安装linux-lts备用内核

Sun, 09 Jul 2023 14:10:06 +0800

由于滚动更新的机制，Arch Linux采用的linux内核更新较频繁，难免会碰到由于内核更新无法进入系统。为了解决由于内核更新导致的系统故障，我们可以同时安装更新周期更长的linux-lts内核，如果linux内核更新后无法进入系统，此时就可以选择加载linux-lts内核进入系统，回退linux内核或者等待修复。

安装linux-lts内核

首先安装linux-lts内核

1

sudo pacman linux-lts linux-lts-headers

此时重启如果使用GRUB引导系统的话，会出现“Advanced Options for Arch Linxu”，选择这一项就会进入选择启动linux内核或者linux-lts内核的自选单。

如果使用rEFInd引导系统的话，此时选择进入Arch Linux会默认加载最后安装的内核即linux-lts，选中Arch Linux图标在按F2键的话就会进入选择加载不同内核的选单。

为了更加方便地在Boot Loader界面选择想要加载的内核，我们可以分别对GRUB和rEFInd进行一些配置。

配置GRUB

我们想要的是在进入GRUB界面后，直接列出了加载不同内核的选项，而不需要先进入子选单再选择内核。编辑/etc/default/grub，取消注释

1

GRUB_DISABLE_SUBMENU=y

如果使用的文件系统不是btrfs，还可以配置GRUB自动选中上一次选择加载的选项，这样可以免除每次重新选择。同样编辑/etc/default/grub，对下面几项进行更改

1
2


GRUB_DEFAULT=saved
GRUB_SAVEDEFAULT=true

修改完成后重新更新引导配置即可

1

sudo grub-mkconfig -o /boot/grub/grub.cfg

配置rEFInd

rEFInd每次会默认加载最后安装的内核，所以如果不按F2进入子选单选择linux内核就会自动加载linux-lts内核。

通过更改rEFInd配置文件，我们可以实现默认加载进入linux内核，然后通过子选单选择加载linux-lts内核。同时我们也可以选择附加内核参数，使得每次加载内核的同时加载微码，防止出现一些意外奔溃。

为了让rEFInd支持Btrfs子卷，需要为rEFInd安装驱动

1
2


# 我的ESP分区挂载在/efi下
sudo cp /usr/share/refind/drivers_x64/btrfs_x64.efi /efi/EFI/refind/drivers_x64/btrfs_x64.efi

编辑rEFInd配置文件/efi/EFI/refind/refind.conf，我的ESP分区挂载在/efi，如果ESP分区挂载在/boot下的话配置文件路径为/boot/efi/EFI/refind/refind.conf。

让rEFInd能够匹配Arch Linux的不同内核

1

extra_kernel_version_strings linux-hardened,linux-zen,linux-lts,linux

让rEFInd能够在Btrfs子卷下自动扫描内核

1

also_scan_dirs boot,ESP2:EFI/linux/kernels,@/boot

为了实现rEFInd默认加载linux内核，修改配置文件/efi/EFI/refind/refind.conf，手动添加启动项

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


# 我使用的是Btrfs文件系统，请更加自己的文件系统和内核位置更改路径选项
menuentry "Arch Linux" {
 icon /EFI/refind/themes/refind-theme-regular/icons/128-48/os_arch.png
 volume "arch" # Arch 文件系统所在卷对应的标签（Label）
 loader /@/boot/vmlinuz-linux # 默认加载linux内核
 initrd /@/boot/initramfs-linux.img # linux内核对应的initramfs
 # options选项需要更据GRUB配置文件中的内核参数更改
 # options的最后一项设定加载Intel微码，需要确定微码的路径
 options "root=UUID=d26ed334-68d4-481d-894f-838783fa4f88 rw rootflags=subvol=@ loglevel=5 nowatchdog initrd=@\boot\intel-ucode.img"
 # 子选单定义，用于加载备用initramfs和linux-lts内核
 submenuentry "Boot using fallback initramfs" {
 initrd /@/boot/initramfs-linux-fallback.img # linux内核的备用initramfs
 }
 submenuentry "Boot to linux-lts" {
 loader /@/boot/vmlinuz-linux-lts # 加载linux-lts内核
 initrd /@/boot/initramfs-linux-lts.img # linux-lts内核对应的initramfs
 }
 submenuentry "Boot to linux-lts using fallback initramfs" {
 loader /@/boot/vmlinuz-linux-lts
 initrd /@/boot/initramfs-linux-lts-fallback.img # linux-lts的备用initramfs
 }
 submenuentry "Boot to terminal" {
 add_options "systemd.unit=multi-user.target" # 进入终端
 }
 # disabled # 注释掉disable才会生效
}

设定启动选项时需要在volume指定内核和initramfs的所处的子卷，volume的值可以设定成/或/boot所处的子卷标签或者GUID。

查看子卷标签

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


❯ sudo lsblk -o name,mountpoint,label,size,uuid
NAME MOUNTP LABEL SIZE UUID
nvme0n1 476.9G
├─nvme0n1p1 SYSTEM_DRV 260M C2B6-5B79
├─nvme0n1p2 16M
├─nvme0n1p3 Windows-SSD 175.7G 9292B82A92B81527
├─nvme0n1p4 Windows 50G B88EF24F8EF20622
├─nvme0n1p5 WINRE_DRV 1000M D800BC7600BC5CE6
├─nvme0n1p6 /home arch 239.5G d26ed334-68d4-481d-894f-838783fa4f88
├─nvme0n1p7 [SWAP] 10G d5792b35-68e7-421d-8dde-365e39e6a92b
└─nvme0n1p8 /efi 512M 6CB0-E267

系统启动时会通过Boot Loader加载内核和ramfs，一般还要指定加载微码。内核文件vmlinuz-linux、内核对应的initramfs-linux.img以及微码intel-ucode.img默认位于/boot文件夹，在rEFInd配置时需要确定自己系统中这些文件实际存在的路径。

Arch Linux启动过程参考Arch boot process。

保存对/efi/EFI/refind/refind.conf更改，此时重启进入rEFInd界面，会多出一个我们刚才定义的启动项，直接选择此项启动会直接加载linux内核，按F2进入此启动项的子选单会出现我们刚才定义的加载fallback initramfs和加载linux-lts内核等选项。选中原先的Arch Linux启动项按Delete隐藏即可。

Arch Linux 配置 -- 驱动和软件安装

Sat, 08 Jul 2023 17:40:07 +0800

最近趁着假期把Manjaro换成了Arch Linux，本文记录了我安装Arch Linux中的一些配置。

Arch Linux安装

安装教程参考archlinux 简明指南和ArchWiki。

安装显卡驱动

本人电脑是联想小新Air13 IWL，有一个Intel核显和一个Nvidia独显。

运行lspci -k | grep -A 2 -E "(VGA|3D)"可以查看显卡信息

1
2
3
4
5
6
7


00:02.0 VGA compatible controller: Intel Corporation WhiskeyLake-U GT2 [UHD Graphics 620]
       Subsystem: Lenovo WhiskeyLake-U GT2 [UHD Graphics 620]
       Kernel driver in use: i915
--
03:00.0 3D controller: NVIDIA Corporation GP108M [GeForce MX150] (rev a1)
       Subsystem: Lenovo GP108M [GeForce MX150]
       Kernel driver in use: nvidia

Intel 驱动

参考ArchWiki-Intel graphics。

首先安装mesa，它提供了用于3D加速得DRI驱动。对于Intel 8代以及更新的硬件选择软件包mesa，对于7代以及更老的芯片选择mesa-amber。

为了支持32位程序，同时安装对应的lib32-mesa或者lib32-mesa-amber。为了Vulkan支持，还需要安装vulkan-intel，以及32位支持包lib32-vulkan-intel。

1

sudo pacman -S mesa lib32-mesa vulkan-intel lib32-vulkan-intel

Nvidia 驱动

建议对照ArchWiki-NVIDIA安装，官方教程更加准确并且可能有更新。

对于新于 Turing (NV160/TUXXX)系列的显卡，如果系统使用linux内核则安装nvidia-open，如果使用其他内核则安装nvidia-open-dkms。
对于较旧且新于 Maxwell (NV110/GMXXX)系列的显卡，如果使用linux内核则安装nvidia，如果使用linux-lts内核则安装nvidia-lts，其他内核则安装nvidia-dkms。
Kepler (NVE0/GKXXX)系列显卡，安装nvidia-470xx-dkms。
更旧的显卡安装开源驱动nouveau。

如果需要32位应用支持，还需安装lib32-nvidia-utils。同时可以安装nvidia-settings用来对nvidia驱动进行一些配置。

1

sudo pacman -S nvidia nvidia-settings lib32-nvidia-utils

不同型号的显卡对应的软件包选择可以参考archlinux 简明指南-显卡驱动，最好同时对照ArchWiki选择。

安装好驱动后，编辑/etc/mkinitcpio.conf，删去HOOKS那一项中得kms，阻止内核启动时加载nouveau。

1
2


# HOOKS=(base udev autodetect modconf keyboard keymap kms consolefont block filesystems fsck) # 更改前
HOOKS=(base udev autodetect modconf keyboard keymap consolefont block filesystems fsck) # 更改后

更改后重新生成initramfs

1

sudo mkinitcpio -P

重启系统，打开nvidia-settings如果可以看到显卡的各种详细信息，则说明安装成功。

核显和独显动态切换

参考双显卡（核显 + 独显）。

安装optimus-manager，它提供了双显卡下切换仅用核显、仅用独显和动态切换三种模式，optimus-manager-qt则提供了模式切换的图形界面。

1

yay -S optimus-manager optimus-manager-qt

启用视频硬件加速

参考ArchWiki-Hardware video acceleration。

首先安装驱动

1

sudo pacman -S intel-media-driver

不同型号的显卡需要安装的驱动包不同，具体要求可以查看ArchWiki。

此时可以使用MPV播放视频检验硬件加速是否启用

1
2
3
4
5
6
7


❯ mpv --hwdec=auto test.mp4
 (+) Video --vid=1 (*) (h264 1920x1080 29.970fps)
 (+) Audio --aid=1 (*) (aac 2ch 44100Hz)
Using hardware decoding (vaapi).
AO: [pulse] 44100Hz stereo 2ch float
VO: [gpu] 1920x1080 vaapi[nv12]
AV: 00:00:02 / 00:03:49 (1%) A-V: 0.000

从终端输出可以看到，此时硬件解码是正常的。

在浏览器中启用视频硬件加速参考[HowTo] Enable Hardware Video Acceleration / Video Decode In Google Chrome, Brave, Vivaldi And Opera Browsers。以我使用的Vivaldi浏览器为例，只需要新建文件~/.config/vivaldi-stable.conf，在其中写入

1
2
3
4
5


--use-gl=angle
--ignore-gpu-blocklist
--enable-features=VaapiVideoEncoder,VaapiVideoDecoder,CanvasOopRasterization
--disable-features=UseChromeOSDirectVideoDecoder,UseSkiaRenderer
--disable-gpu-driver-workarounds

此时在浏览器中进入vivaldi:gpu，已经正常启用了硬件加速。

Windows 和 Linux 共用蓝牙

安装双系统后，每次切换系统都需要重新配对蓝牙设备。但是可以通过改变Linux系统中蓝牙设备的配对参数，实现两个系统共用一个蓝牙配对，这些切换系统后旧不用重新配对，直接可以自动连接蓝牙了。

首先在Linux里配对蓝牙设备，然后重启进入Windows重新配对蓝牙。

下载PSEXEC，以管理员身份启动终端，进入PSEXEC解压后的文件夹，运行

1

./psexec.exe -s -i regedit

在打开的页面中展开HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\BTHPORT\Parameters\Keys，里面有一个以Windows蓝牙控制器的MAC地址命名的文件夹，打开该文件夹，里面的文件夹名对应的是蓝牙设备的MAC地址，记下蓝牙设备的MAC地址和里面注册表的值。

重启进入Linux，进入/var/lib/bluetooth，其中有一个以Linux蓝牙管理器MAC地址命名的文件夹，进入该文件夹，里面的文件夹以蓝牙设备的MAC地址命令，把这个文件夹重命名为和Windows中相同的MAC地址值。例如在我的电脑中，Windows中MAC地址为ffa68a9feeb2，在Linux中就改为FF:A6:8A:9F:EE:B2。

1
2
3
4
5
6
7


F8:A2:D6:C9:7C:10 # Linux蓝牙管理器MAC地址
├── cache
│   └── FF:A6:8A:9F:EE:B2
├── FF:A6:8A:9F:EE:B2 # 蓝牙设备MAC地址，改成和Windows相同的值
│   ├── attributes
│   └── info
└── settings

然后编辑FF:A6:8A:9F:EE:B2中的info文件，将相关的蓝牙配对参数改为和Windows相同，需要更改的值如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[LocalSignatureKey]
Key=E03086C6AAAB88CF623E57F2361E6488 # 和Windows中CSRK相同
Counter=0
Authenticated=false

[LongTermKey]
Key=4BA30A70E71C729CC23D12EF29B8C889 # 和Windows中LTK相同
Authenticated=0
EncSize=16
EDiv=11107 # 和Windows中EDIV相同
Rand=12409689061704920446 # 和Windows中ERand相同

重启蓝牙，蓝牙设备就会自动连接

1

sudo systemctl restart bluetooth

使用rEFInd引导系统

rEFInd是一个适用于UEFI的Boot Manager，支持自定义主题，可以替代界面简陋的GRUB，用来引导Linux和Windows双系统。 rEFInd和GRUB的关系可以参考这里。首先安装rEFInd软件包

1

sudo pacman -S refind

将rEFInd引导文件安装到ESP分区

1

refind-install

配置rEFInd主题，我选择的主题是refind-theme-regular，自动安装命令如下

1

sudo bash -c "$(curl -fsSL https://raw.githubusercontent.com/bobafetthotmail/refind-theme-regular/master/install.sh)"

官方默认安装主题到/boot/efi/EFI/refind/themes/refind-theme-regular，如果在安装Arch时选择将ESP分区挂在在/efi的话，需要按照官方的手动安装指导将主题安装到/efi/EFI/refind/themes/refind-theme-regular。最终的主题效果如下

如果引导页面有多余项的话，可以按键盘上的Delete键隐藏该启动项。如果未出现rEFInd引导页，可以在电脑的BIOS设置界面将rEFInd启动项置顶。

安装MATLAB

我在安装时采用的是MATLAB 2022a安装包，在终端运行安装脚本，出现报错

1

/home/xu/Downloads/R2022a_Linux/bin/glnxa64/MathWorksProductInstaller: error while loading shared libraries: libcrypt.so.1: cannot open shared object file: No such file or directory

这是由于系统缺少libxcrypt，使用pacman安装相应软件包

1

sudo pacman -S libxcrypt-compat

再次运行安装脚本，出现报错信息

1
2
3


terminate called after throwing an instance of 'std::runtime_error'
 what(): Failed to launch web window with error: Unable to launch the MATLABWindow application. The exit code was: 127
[1] 3019 IOT instruction (core dumped) ./install

此时可以按照ArchWiki-MATLAB中的指导进行排查错误来源，为了找出为何MATLABWindow无法加载，在MATLAB安装文件中执行以下命令，查看输出的报错信息

1
2


./bin/glnxa64/MATLABWindow
./bin/glnxa64/MATLABWindow: error while loading shared libraries: libgtk-x11-2.0.so.0: cannot open shared object file: No such file or directory

可以看到系统中无法找到libgtk-x11-2.0.so.0，安装缺失的软件包

1

sudo pacman gtk2

再次运行./bin/glnxa64/MATLABWindow，出现错误信息

1

./bin/glnxa64/MATLABWindow: symbol lookup error: /usr/lib/libharfbuzz.so.0: undefined symbol: FT_Get_Color_Glyph_Layer

此时的报错信息已经和ArchWiki一致，按照说明添加环境变量，再次运行安装脚本

1
2


export LD_PRELOAD=/lib64/libfreetype.so
./install

这时MATLAB安装界面可以正常运行，正常安装即可。

如果在MATLAB运行时碰到问题，可以参考我之前写的Manjaro Linux 安装 MATLAB，里面记录了诸如设置无法保存、无法开启OpenGL加速等各种问题。

Manjaro Linux 安装 MATLAB

Sun, 19 Mar 2023 18:40:57 +0800

最近从 Windows 换到了 Manjaro，日常离不开 MATLAB，虽然 MATLAB 官方提供了 Linux 版本，但是没有对 Manjaro 做适配，所以在安装 MATLAB 的过程中遇到了各种问题，以此记录。任何其他问题建议查阅ArchWiki。

MATLAB 安装报错

最初安装的时候，我下载的是 MATLAB 2020b 的 iso 镜像，即使按照 ArchWiki 的指导，移除了libfreetype.so*还是会继续报错。后来换成 MATLAB 2022a 的镜像才成功安装。
进入 MATLAB 2022a 安装文件所处的文件夹，运行./install，出现报错

1
2
3


terminate called after throwing an instance of 'std::runtime_error'
 what(): Failed to launch web window with error: Unable to launch the MATLABWindow application. The exit code was: 127
[1] IOT instruction (core dumped) ./install

此时可以运行

1

./bin/glnxa64/MATLABWindow

应该会出现报错信息

1

bin/glnxa64/MATLABWindow: symbol lookup error: /usr/lib/libcairo.so.2: undefined symbol: FT_Get_Color_Glyph_Layer

FT_Get_Color_Glyph_Layer是 freetype2 里的一个符号，只要删除 MATLAB 安装文件夹里的libfreetype.so*，执行

1

rm ./bin/glnxa64/libfreetype.so*

或者也可以添加环境变量

1

LD_PRELOAD=/lib64/libfreetype.so

此时再执行./install就可以成功打开 MATLAB 安装引导。
解决方案来源：ArchWiki-MATLAB

MATLAB 界面内中文无法显示

安装完成，打开 MATLAB 却发现中文乱码，所有的中文都是方块。MATLAB 的界面是用 JAVA 开发的，中文无法显示是因为 JAVA 的中文字体配置问题。
此时进入 MATLAB 的安装路径下的 jre 目录，我的 MATLAB 安装在/usr/local/MATLAB/R2022a，进入该文件夹

1

cd /usr/local/MATLAB/R2022a/sys/java/jre/glnxa64/jre/lib/fonts

在此目录下新建fallback文件夹

1

mkdir fallback

将中文字体移动到 fallback 文件夹，我使用的字体是 NotoSansCJK-Regular.ttc，想要获取改字体可以先运行sudo pacman noto-fonts-cjk，然后在/usr/share/fonts/noto-cjk就可找到字体文件。

1

sudo cp /usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc /usr/local/MATLAB/R2022a/sys/java/jre/glnxa64/jre/lib/fonts/fallback

复制完字体文件后，在fallback文件夹内，运行

1

mkfontscale

此时会生成fonts.scale，打开fonts.scale，将其中内容复制到上级目录/usr/local/MATLAB/R2022a/sys/java/jre/glnxa64/jre/lib/fonts中的fonts.dir
注意fonts.dir没有可写权限，需要先授予可写权限

1

sudo chmod 6 fonts.dir

此时进入 MATLAB 就可以正常显示中文了。
解决方案来源：Linux 下 Matlab 的安装和中文显示支持。
如果 MATLAB 的终端无法显示中文，可以在 MATLAB 内主页-预设-字体下的两个字体选项里选择中文字体（如果设置无法保存请参考下节）。

MATLAB 的设置无法保存

在 MATLAB 的设置界面更改设置选项，发现退出 MATLAB 后在重新打开，所有的设置会恢复默认值，这是因为 MATLAB 无法使用/tmp 文件夹。新建文件夹

1

mkdir ~/.cache/matlab-tmp

在/home/xuq/.local/share/applications为 MATLAB 建立一个启动方式matlab.desktop，文件内容为

1
2
3
4
5
6
7
8


[Desktop Entry]
Type=Application
Version=R2022b
Name=MATLAB
Comment=Scientific computing software
Icon=/home/<username>/.local/share/applications/matlab_logo.png
Exec=bash -c "export TMPDIR=/home/<username>/.cache/matlab-tmp; /usr/local/MATLAB/R2022a/bin/glnxa64/MATLAB -desktop; rm -r $TMPDIR"
Terminal=False

注意替换 MATLAB 可执行文件的路径，以及 MATLAB 的 Icon 路径。
解决方案来源：Why aren’t my MATLAB preferences saved on Linux?。

MATLAB 无法打开文本编辑器

在 MATLAB 中新建脚本或者打开脚本时，出现报错Unable to open this file in the current system configuration，终端输出

1
2
3
4
5
6
7
8
9


Exception in thread "AWT-EventQueue-0": java.lang.NullPointerException
 at com.mathworks.mde.desk.MLDesktop.updateTemplate(MLDesktop.java:3665)
 at com.mathworks.mde.desk.MLDesktop.access$2000(MLDesktop.java:225)
 at com.mathworks.mde.desk.MLDesktop$NewMFileAction.actionPerformed(MLDesktop.java:2853)
 at com.mathworks.mwswing.ChildAction.actionPerformed(ChildAction.java:214)
 at javax.swing.AbstractButton.fireActionPerformed(AbstractButton.java:2022)
 at javax.swing.AbstractButton$Handler.actionPerformed(AbstractButton.java:2348)
 at javax.swing.DefaultButtonModel.fireActionPerformed(DefaultButtonModel.java:402)
......

此时只需要进入 MATLAB 的安装路径，去除libfreetype.so.6

1
2


cd /usr/local/MATLAB/R2022a/bin/glnxa64
mv libfreetype.so.6 libfreetype.so.6.old

解决方案来源：MATLAB cannot create or open script files。

MATLAB 界面缩放过小

MATLAB 的界面、字体和图标在 Linux 下很小，无法随着系统缩放而改变。以 MATLAB 界面放大 1.25 倍为例，在 MATLAB 终端输入

1
2


>> s = settings;s.matlab.desktop.DisplayScaleFactor
>> s.matlab.desktop.DisplayScaleFactor.PersonalValue = 1.25

解决方案来源：Does MATLAB support High DPI screens on Linux?。

MATLAB 无法使用 OpenGL 加速

MATLAB 绘图时终端输出

1
2
3
4


Warning: MATLAB previously crashed due to a low-level graphics error.
To prevent another crash in this session, MATLAB is using software OpenGL instead of using your graphics hardware.
To save this setting for future sessions, use the opengl('save', 'software') command.
For more information, see Resolving Low-Level Graphics Issues.

设置由于 MATLAB 无法使用 OpenGL 硬件加速，导致图形渲染能力下降，在 3D 绘图时可能出错。
进入 MATLAB 可执行文件所在的路径

1
2


cd /usr/local/MATLAB/R2022a/bin/glnxa64
MATLAB -nodesktop -nosplash -r "opengl info; exit" | grep Software

如果终端中输出的software rendering值不是false（0 也不行）,说明此时未启用硬件加速。查看系统的 OpenGL 配置

1

glxinfo | grep "direct rendering"

如果direct rendering的值为yes说明配置正确，否则先要解决 OpenGL 的系统配置。如果系统的 OpenGL 配置正确，更改先前创建的 MATLAB 启动方式，在/home/xuq/.local/share/applications打开matlab.desktop，在 Exec 项添加 MATLAB 运行时的环境变量，将其更改为

1

Exec=bash -c "export TMPDIR=/home/xuq/.config/matlab-temp; export LD_PRELOAD=/usr/lib/libstdc++.so; export LD_LIBRARY_PATH=/usr/lib/dri/; /usr/local/MATLAB/R2022a/bin/glnxa64/MATLAB -desktop; rm -r $TMPDIR"

然后在 MATLAB 可执行文件所在的路径下新建文件

1

touch /usr/local/MATLAB/R2022a/bin/glnxa64/java.opts

在java.opts中写入-Djogl.disable.openglarbcontext=1。解决方案来源：ArchWiki-MATLAB。

Windows下制作ChromeOS Live USB

Sun, 05 Feb 2023 11:02:40 +0800

ChromeOS是Google推出的桌面操作系统，主打基于云应用的轻量操作系统，如今的ChromeOS已经支持Linux模式和直接运行Android应用。由于Google没有开放系统给Chromebook以外的设备，一般电脑安装ChromeOS可以借助开源项目brunch。

brunch能够利用ChromeOS的recovery文件，生成可用的系统镜像文件，从而在非Chromebook上安装原生ChromeOS。

硬件要求

x86_64架构，UEFI启动模式
Intel CPU至少第四代，或者AMD Ryzen
不支持独显，不支持虚拟机，不支持Arm
可以安装Linux子系统（WSL2）的Windows或者Linux系统
空闲空间至少有16G

安装ChromeOS到U盘

下载ChromeOS recovery文件。

参考自己的CPU型号，选择一个和自己电脑配置接近的chrome设备，在Chromium Dash下载该设备的recovery文件，一般选择最新的发行版本即可。

我选择的是Lenovo Yoga C630 Chromebook，codename为pantheon，下载发行版本为109的recovery文件。

如果不知道应该下载哪个recovery，brunch的项目文档里也给了推荐的recovery。
- Intel
  - 1代-9代：选择codename为rammus的设备对应的recovery
  - 10代和11代：选择codename为volteer的设备对应的recovery
- AMD Ryzen：选择codename为zork的设备对应的recovery
下载brunch的release文件

在brunch的release页面下载和recovery版本号对应的文件，例如下载的recovery为109，则下载Brunch r109。
制作ChromeOS镜像文件

将下载好的Brunch和ChromeOS recovery放在一个文件夹，分别解压。

打开WSL终端，安装必要软件。
1

sudo apt update && sudo apt -y install pv cgpt tar unzip
在终端中运行命令，制作ChromeOS镜像。把chromeos_filename.bin用从recovery中解压得到的文件名替代，脚本运行完成后回到的名为chromeos.img的系统镜像。
1

sudo bash chromeos-install.sh -src chromeos_filename.bin -dst chromeos.img
命令运行完成后直接键入ENTER结束。
将镜像文件写入U盘

下载Rufus，选中要使用的U盘和镜像文件，将镜像写入U盘。
进入ChromeOS

重启电脑，进入BIOS设置界面，关闭secure boot，设置优先从USB启动。

保存并退出BIOS设置，电脑会自动重启并从U盘启动系统，第一次进入系统时需要等待较长时间。

安装ChromeOS和Windows双系统

获取文件以及解压同“安装ChromeOS到Windows”中的步骤1、2、3。

安装ChromeOS双系统同样通过在WSL终端中运行脚本完成，首先新建一个文件夹用于安装系统如/mnt/d/brunch，表示在d盘新建文件夹brunch，然后输入命令。

1

sudo bash chromeos-install.sh -src chromeos_filename.bin -dst /mnt/d/brunch/chromeos.img -s size

把命令中的chromeos_filename.bin用从recovery中解压得到的文件名替代，size用一个数字替代，定义了分配给ChromeOS磁盘空间，不小于14并且为4的倍数（单位GB）。

等待脚本执行完成后输入dualboot然后键入ENTER。

下一步可以安装Grub2Win，实现在开机时选择想要进入的系统。本人未作尝试，具体步骤可以参考brunch的官方安装教程。
安装Grub2Win后，依次点击Manage Boot Menu-Add A New Entry-Type，选择“Create user section”。此时为自动用记事本新建一个文本文件，在之前设置的/mnt/d/brunch文件夹中打开“chromeos.grub.txt”，将该文件中的内容复制到新建的空文本中。保存Grub2Win的更改，重启电脑，选择ChromeOS进入系统。

Telegram Bot（一）Python库pyTelegramBotAPI的使用

Tue, 10 Jan 2023 19:39:43 +0800

基于Python的Telegram Bot，使用pyTelegramBotAPI库。

准备

创建Bot

点击START私聊@BotFather，输入/newbot开始创建Bot。

等到BotFather回复后输入想要创建的Bot名称，BotFather再次回复后输入Bot的username，注意username必须以_bot结尾。

创建完Bot后就可以获取到Bot的token，Telegram Bot API的调用必须提供token。

安装pyTelegramBotAPI

使用pip安装pyTelegramBotAPI。

1

pip install pyTelegramBotAPI

Bot的运行原理

Bot和一般的用户一样，都有名称和id，可以通过@username查找到Bot。Bot的运行是通过和所有者服务器上的脚本联合实现的，用户通过Telegram向Bot发送信息，Bot的脚本根据Bot的token，就可以在服务器上通过Telegram提供的Bot API获取到用户发送给Bot的信息，从而实现根据用户发送的信息返回给用户相应的回复。

pyTelegramBotAPI是一个Python库，对Telegram Bot API进行了封装。使得开发者不用对API直接调用，使用pyTelegramBotAPI提供的函数和类就可以实现Telegram Bot API的各种功能。

pyTelegramBotAPI的基础使用

新建bot对象

pyTelegramBotAPI中调用API的methods全部定义在TeleBot类中，通过传入Bot token新建bot对象。

1
2
3


import telebot

bot = telebot.TeleBot("TOKEN", parse_mode=None) # You can set parse_mode by default. HTML or MARKDOWN

TeleBot类中的函数和Telegram Bot API提供的method同名，但是更改了命名规则，例如API中的getMe在TeleBot类对应于get_me，API中的sendMessage被命名为send_message。

Bot提供给用户的回复是通过handler实现的，对于用户发送给Bot的消息，使用message handler进行处理。

1
2
3


@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
 bot.reply_to(message, "Howdy, how are you doing?")

上述代码中表示对于用户发送给Bot的消息，定义一个message_handler，这个message_handler在用户发送了指令/start或/help时执行send_welcome函数，产生对用户的回复”Howdy, how are you doing?“。

message对象

用户对Bot发送消息后，通过Telegram Bot API获得到的是一个名为message的JSON对象，包含了消息内容，用户id等相关信息，详情可参考Telegram官方文档。

在上述给出的message_handler示例代码中，send_welcome函数传入参数message对象，reply_to通过message中包含的属性chat.id等获取用户id，从而向用户发送回复信息。

需要注意的是，由于from是Python中的保留字，在pyTelegramBotAPI中，message的属性名from被替换为from_user。

message handler

message handler用来对用户发送的message类消息做出反应（用户发送的消息一般都为message，除此之外还有投票poll、频道推文channel post等其他类型），用于处理其他类消息的handler还有poll handler、channel post handler等。

1
2
3


@bot.message_handler(filters)
def function_name(message):
 bot.reply_to(message, "This is a message handler")

在message handler的一般形式中，filters用来对message进行筛选，使该message_handler只对特定类型的message进行响应。filters的一般格式为name=argument，name表示筛选类型，argument代表筛选范围。例如commands=['start', 'help']表示只对命令/start和/help做出反应。

官方给出的filters支持的类型如下：

name	argument	Condition
content_types	list of strings (default [’text’])	True if message.content_type is in the list of strings.
regexp	a regular expression as a string	True if re.search(regexp_arg) returns True and message.content_type == ’text’ (See https://docs.python.org/2/library/re.html)
commands	list of strings	True if message.content_type == ’text’ and message.text starts with a command that is in the list of strings.
chat_types	list of chat types	True if message.chat.type in your filter
func	a function (lambda or function reference)	True if the lambda or function reference returns True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


import telebot
bot = telebot.TeleBot("TOKEN")

# 只处理命令 '/start' 和 '/help'
@bot.message_handler(commands=['start', 'help'])
def handle_start_help(message):
 pass

# 只处理用户发送内容为“文件”和“音频”的message
@bot.message_handler(content_types=['document', 'audio'])
def handle_docs_audio(message):
 pass

# Handles all text messages that match the regular expression
@bot.message_handler(regexp="SOME_REGEXP")
def handle_message(message):
 pass

# Handles all messages for which the lambda returns True
@bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
def handle_text_doc(message):
 pass

# Which could also be defined as:
def test_message(message):
 return message.document.mime_type == 'text/plain'

@bot.message_handler(func=test_message, content_types=['document'])
def handle_text_doc(message):
 pass

# Handlers can be stacked to create a function which will be called if either message_handler is eligible
# This handler will be called if the message starts with '/hello' OR is some emoji
@bot.message_handler(commands=['hello'])
@bot.message_handler(func=lambda msg: msg.text.encode("utf-8") == SOME_FANCY_EMOJI)
def send_something(message):
 pass

完全卸载VMware Workstation

Sat, 19 Mar 2022 12:05:03 +0800

之前没有通过引导卸载VMware Workstation，直接把整个文件夹删了，导致卸载不彻底。VMware在安装时会先检测是否已经安装，使得我的电脑无法再次安装VMware Workstation。后来按照官方的卸载教程试了几次都没成功，偶然发现系统环境变量中还有VMware的路径，才解决了这个问题。关键在于卸载后没有删除环境变量，所以被认为没有完全卸载VMware Workstation。

通过Workstation安装程序自动清理

下载对应版本的安装程序，在当前文件夹打开终端，在终端中输入

1

VMware-workstation-full-xxx-xxx.exe /clean

停止VMware相关的服务

在Windows搜索框搜索services.msc，打开“服务”，停止所有VMware相关的服务。

VMware Authorization Service
VMware Authentication Service
VMware Registration Service
VMware DHCP Service
VMware NAT Service
VMware USB Arbitration Service
VMware Workstation Server
VMware WSX Service

删除VMware network bridge adapter

打开控制面板\网络和 Internet\网络连接
右键，属性，选择VMware Bridge Protocol，卸载

删除VMware相关的网络适配器

打开控制面板\硬件和声音\设备管理器
在“查看”工具栏勾选上“显示隐藏的设备”
点击“网络适配器”，卸载名字包含VMware的适配器

删除和VMware有关的文件夹

程序安装目录
数据目录
默认路径C:\Program Files(X86)\VMware\
开始菜单中的VMware
路径C:\ProgramData\VMware
快捷方式
其他文件
- C:\Windows\system32\vmnat.exe
- C:\Windows\system32\vmnetbridge.exe
- C:\Windows\system32\VMNetDHCP.exe
- C:\Windows\system32\vmnetdhcp.leases
- C:\Windows\system32\vmxw2ksetup.dll
- C:\Windows\system32\vnetprobe.exe
- C:\Windows\system32\vnetprobelib.dll
- C:\Windows\system32\vnetinst.dll
- C:\Windows\system32\vnetlib.dll
- C:\Windows\system32\vnetlib.exe
- C:\Windows\system32\drivers\vmnet.sys
- C:\Windows\system32\drivers\vmnetx.sys
- C:\Windows\system32\drivers\VMparport.sys
- C:\Windows\system32\drivers\vmx86.sys
- C:\Windows\system32\drivers\vmnetadapter.sys
- C:\Windows\system32\drivers\vmnetbridge.sys
- C:\Windows\system32\drivers\vmnetuserif.sys
- C:\Windows\system32\drivers\hcmon.sys
- C:\Windows\system32\drivers\vmusb.sys
注册表
打开注册表管理器，删除以下注册表
- HKEY_CLASSES_ROOT\Installer\Features\A57F49D06AE015943BFA1B54AFE9506C
- HKEY_CLASSES_ROOT\Installer\Products\A57F49D06AE015943BFA1B54AFE9506C
- HKEY_CLASSES_ROOT\Installer\UpgradeCodes\3F935F414A4C79542AD9C8D157A3CC39
- HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{0D94F75A-0EA6-4951-B3AF-B145FA9E05C6}
- HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\VMware, Inc.\VMware Workstation
- HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\VMware, Inc.\Installer\VMware Workstation
- HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Applications\vmware.exe

删除环境变量

打开系统环境变量设置，删除VMware Workstation的执行路径
重启电脑，就完成了VMware Workstation的完全卸载。
各版本路径存在一些不同，具体参考官方文档。

将Hugo博客部署到Github Pages

Sat, 12 Feb 2022 19:34:01 +0800

关于Hugo

Hugo的便利之处在于，用户只需编辑markdown文档，Hugo会自动将markdown文档转换为网页。Hugo根据存放于content文件夹中的用户markdown文件，生成网页源文件，并存放于public文件夹中。

将博客部署到GitHub Pages，只需将Hugo生成的public文件夹推送到GitHub仓库。

关于Github Pages

官方文档定义：

GitHub Pages is a static site hosting service that takes HTML, CSS, and JavaScript files straight from a repository on GitHub, optionally runs the files through a build process, and publishes a website.

Github Pages 有两种形式，个人/组织页面和项目页面，两者访问时的url不同，为了能够使用https://<USERNAME|ORGANIZATION>.github.io/访问个人博客，应当设置成个人页面。

User/Organization Pages (https://<USERNAME|ORGANIZATION>.github.io/)
Project Pages (https://<USERNAME|ORGANIZATION>.github.io/<PROJECT>/)

创建User Page

在Github新建仓库时，个人页面的创建和项目页面不同：

用于个人页面的仓库必须被用户（而不是组织）所有，并将仓库命名为<username>.github.io
个人页面的源文件放置于仓库的默认分支中，项目页面需存放在特定分支

创建仓库时需要注意，免费用户创建的页面仓库必须设置为Public

选择 Initialize this repository with a README ，完成仓库创建

将源文件推送到仓库

在创建的仓库中复制远程仓库地址

在Hugo生成的文件夹中，在终端中输入

1
2
3
4
5
6
7


hugo #生成网页源文件
cd public #生成的源文件存放在public文件夹中，只需将该文件夹推送到所创建的仓库中
git init #git初始化
git remote add origin git@github.com:<username>/<username>.github.io.git #关联远程仓库
git add .
git commit -m "first commit" #在本地提交更改
git push -u origin master #将更改推送到远程仓库

此时GitHub仓库中拥有main和master两个分支，其中main分支是创建仓库是自动生成的默认分支，mater分支由本地推送，即博客的网页源文件

GitHub Pages的个人页面默认从main分支提取网页源文件，所以还需要在仓库的settings-pages-source中将分支改为master分支

之后即可通过<username>.github.io访问博客页面