最近在在研究如何对NAS进行备份，在网上找了很久，基本上是通过Hyper Backup备份到移动硬盘备份或者另一台群晖NAS。但这并不能满足我的需求：

• 备份到移动硬盘：移动硬盘的容量一般在1T~2T，容量基本满足需求，但是无法移动存储，且存储介质不能保证高可靠，一旦移动硬盘故障，就会导致数据丢失。
• 备份到另一台NAS：备份数据高可靠，但是费钱，而且异地备份需要有第二个家，就更缺钱了。

因此调研了一下国内云厂商的对象存储（Object Storage Service, OSS)，能够提供高可靠存储且价格勉强能够接受。一般情况下，100元/年可以购买到约100G/年的存储空间，下图是京东云的OSS价格

综上所属，我最终选择了京东云的OSS，并购买了150GB容量+50GB的下行流量。

就在我购买后的一个月，我发现了更廉价的异地备份方案，就是通过阿里云盘进行备份数据。

阿里云盘邀请链接

阿里云盘介绍

阿里云盘是阿里云推出的一款不限速的云盘，用户默认空间是500GB，足够大多数用户使用。

阿里云盘支持分享，不过分享之前需要进行实名认证，还是比较讨厌的。如果要分享一些不太合适的文件/视频，建议不要使用阿里云盘分享。

阿里云盘还支持做任务增加容量，不过增加的容量一般是有有效期的（一般是1年），目前我的云盘容量大约5TB，足够用很长时间了。

现在通过邀请注册阿里云盘，还可以额外获得500GB容量（有效期1年）。

阿里云盘邀请链接

基于阿里云盘搭建WebDAV

目前有两个开源项目可以把阿里云盘变成WebDAV，通过WebDAV接口就可以让群晖NAS进行备份，黑白群晖均支持。

仓库地址：

• zxbu/webdav-aliyundriver
• messense/aliyundrive-webdav

从我的使用体验来看，zxbu/webdav-aliyundriver比较稳定，但是比较吃资源，容器正常状况下大约占用300MB+内存。messense/aliyundrive-webdav比较轻量，运行时占用约50MB。

两者的配置方法是类似的，都是需要通过Docker，如果没有Docker的用户需要到套件中心中进行安装。若NAS本身不支持Docker，可以将容器部署在局域网的其他设备中国，如PC或者路由器等。

PS: 以下操作全部是基于zxbu/webdav-aliyundriver，messense/aliyundrive-webdav的操作也是相似的。

1. 下载Docker镜像

   打开Docker套件，选择注册表，在右上角的搜索框中输入webdav-aliyundriver或者aliyundrive-webdav，在搜索结果中选择对应的镜像进行下载。
   

2. 启动镜像

   打开Docker套件，选择映像，并选择对应的镜像，点击上方启动按钮。
   

3. 配置镜像

   1. 根据自己的需要设置容器的名称，并且点击下放的高级设置
      

   2. 在弹出高级设置界面中，勾选启用自动重新启动。
      

   3. 选择存储空间标签，点击添加文件夹，在弹出的界面中可以选择/创建一个空文件夹作为容器的配置文件夹。并将文件夹挂载到/etc/aliyun-driver/，一定不要勾选只读。
      

   4. 选择端口设置标签，本地端口是你后续要访问webdav的端口，可以自己随意设置，容器端口必须是8080，协议是TCP。
      

   5. 选择环境标签，添加以下四个环境变量：

      • 变量名：ALIYUNDRIVE_AUTH_USER_NAME，WebDAV访问时需要填写的用户名

      • 变量名：ALIYUNDRIVE_AUTH_PASSWORD，WebDAV访问时需要填写的密码

      • 变量名：ALIYUNDRIVE_REFRESH_TOKEN，登陆阿里云盘的token，获取方法可以参考：通过浏览器获取Refresh Token

      • 变量名：TZ，值：Asia/Shanghai，设置时区为北京时间

        

   6. 点击应用完成容器配置

4. 启动容器

   点击下一步，再点击完成即可启动容器。
   

设置Hyper Backup

如果没有Hyper Backup的用户需要到套件中心中进行安装。

1. 创建备份任务

   1. 打开Hyper Backup套件，点击左上方加号，选择数据备份任务
      

   2. 备份目标选择文件服务器——WebDAV，并点击下一步
      

   3. 配置WebDAV文件服务器信息

      • 服务器地址：如果在NAS的Docker中部署的WebDAV，就填写http://127.0.0.1:8080，端口为之前启动Docker时对外暴露的端口。若在外部Docker部署的WebDAV，则需要填写对应服务器的IP地址和端口。

      • 用户账号：启动容器时配置ALIYUNDRIVE_AUTH_USER_NAME环境变量对应的值

      • 密码：启动容器时配置ALIYUNDRIVE_AUTH_PASSWORD环境变量对应的值

      • 文件夹：选择一个阿里云盘中的文件夹作为备份地址

      • 目录：输入NAS备份目录名称

        

   4. 选择需要备份的共享文件夹，可以按子目录选择/排除，也可以配置文件过滤器进行自定义过滤。
      

   5. 选择需要备份的应用套件，注意，有些套件会要求必须备份某些共享文件夹。
      

   6. 设置备份任务的执行周期，强烈建议开启客户端加密，因为不确定阿里云盘是否会扫描你的备份数据，加密后的密码一定要记牢，一旦丢失就无法找回。
      

   7. 设置备份版本替换规则，建议使用Smart Recycle，会自动根据时间保留各个版本，时间距离越近，保留的版本越多，时间距离越远，保留的版本越少。

      

2. 开始备份

   点击立即备份，就开始执行备份任务了，可以在阿里云盘中看到对应备份文件
   

结语

阿里云盘的容量速度还是非常不错的，完美的平衡了容量和价格，并且是高可靠异地存储，哪怕NAS机械故障后，也能找回数据。

数据无价，大家保存好自己的数据，一旦丢失，就再也找不回来了。

• 已经安装KVM或者Virtual Box的Ubuntu 16.04 64bit。
• 下载MPQUIC镜像，下载地址，下载后解压。

配置环境

创建虚拟机

1. 在KVM或者Virtual Box中创建一个虚拟机，内存推荐2G以上。
2. 虚拟机硬盘为下载的MPQUIC镜像。
3. 设置虚拟机的网卡为e1000，其他的网卡可能不支持。
4. 启动虚拟机，用户名和密码均为mininet。
5. 测试虚拟机是否可以上网。

部署测试环境

1. 挂载内存盘，虚拟机每次重启都要进行该步骤。

   1 2 3 4

   bash ~/mount_tmpfs.sh # 或者 sudo mkdir -p /mnt/tmpfs sudo mount -t tmpfs -o size=256M tmpfs /mnt/tmpfs

2. 创建ssh密钥

   1 2 3

   ssh-keygen # 一直回车即可，之前创建过的可以忽略 # 设置ssh免密登录 ssh-copy-id mininet@localhost

3. 安装依赖

   1	sudo apt install python-dev python-pip python-numpy

4. 下载测试脚本

   1 2	cd ~/git git clone https://github.com/qdeconinck/minitopo-experiences.git

运行测试脚本

1. 修改脚本参数，将待运行的脚本中的REMOTE_SERVER_RUNNER_PORT的值修改为["22"]。

   1 2	# 以quic_mptcp_https_tests_expdes_wsp_highbdp_loss_quic.py脚本为例 vim ~/git/minitopo-experiences/experiences/quic_mptcp_https_tests_expdes_wsp_highbdp_loss_quic.py

2. 运行脚本。脚本运行很慢，且无法用Ctrl-C终止，建议使用tmux或者screen等软件运行。

   1	python ~/git/minitopo-experiences/experiences/quic_mptcp_https_tests_expdes_wsp_highbdp_loss_quic.py

3. 查看运行结果。运行结果保存在/mnt/tmpfs中，测试结束后应及时复制出来，因为该目录为内存盘，重启后数据会丢失。

引言

由于群晖没有获得DTS的版权，因此群晖自带的VideoStation从某个版本开始不支持DTS、EAC3、TrueHD的音频格式，严重影响使用体验。搜索该问题，得到的答案均为将VideoStation降级到2.3.4-1468，但是这个版本的VideoStation不支持HEVC和4K解码，比较鸡肋。本文将利用第三方的ffmpeg替换VideoStation中自带的ffmpeg，实现对全视频格式的支持。

操作方法

安装ffmpeg

1. 下载对应版本的ffmpeg安装包，其中DS918+对应的版本是apollolake，具体每个机型对应的版本可以在以下连接中找到：https://github.com/SynoCommunity/spksrc/wiki/Architecture-per-Synology-model

   下载地址：https://github.com/th0ma7/synology/tree/master/packages

2. 登录DSM，打开套件中心，点击手动安装，选择刚刚下载的文件进行安装。

3. 在DSM中打开控制面板，选择终端机和SNMP，勾选启动SSH功能，并调整对应的端口号。

4. 用XSheel等软件以SSH的方式登录到NAS中，执行以下命令：

   1 2 3

   sudo chmod +s /var/packages/ffmpeg/target/bin/ffmpeg sudo chmod +s /var/packages/ffmpeg/target/bin/ffprobe sudo chmod +s /var/packages/ffmpeg/target/bin/vainfo

安装VideoStation

1. 登录DSM，打开套件中心，安装最新版的VideoStation，本文撰写时，版本为2.4.7-1603，经测试，以下版本适用于本方法，其他版本未测试：2.4.6-1594，2.4.7-1603

2. 用XSheel等软件以SSH的方式登录到NAS中，执行以下命令：

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

# 备份
sudo  sed -i'-BACKUP' -e 's/eac3/ZAAP/' -e 's/dts/ZAP/' -e 's/truehd/ZAPZAP/' /var/packages/VideoStation/target/lib/libsynovte.so
# 注意：ffmpeg的备份名称ffmpeg-BACKUP应与ffmpeg自定义脚本中$bin2保持一致
sudo mv /var/packages/VideoStation/target/bin/ffmpeg /var/packages/VideoStation/target/bin/ffmpeg-BACKUP
sudo mv /var/packages/VideoStation/target/bin/ffprobe /var/packages/VideoStation/target/bin/ffprobe-BACKUP
sudo mv /var/packages/VideoStation/target/bin/vainfo /var/packages/VideoStation/target/bin/vainfo-BACKUP

# 更新/var/packages/VideoStation/target/ffmpeg为自定义脚本，调用第三方的ffmpeg
# 具体脚本信息见附录
sudo su
echo "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" | base64 -d | gunzip > /var/packages/VideoStation/target/bin/ffmpeg
exit

# 更新ffprobe vainfo
sudo ln -s /var/packages/ffmpeg/target/bin/ffprobe /var/packages/VideoStation/target/bin/ffprobe
sudo ln -s /var/packages/ffmpeg/target/bin/vainfo /var/packages/VideoStation/target/bin/vainfo

# 解除对EAC3 DTS TrueHD的屏蔽
sudo sed -i'-BACKUP' -e 's/eac3/ZAAP/' -e 's/dts/ZAP/' -e 's/truehd/ZAPZAP/' /var/packages/VideoStation/target/lib/libsynovte.so

# 调整权限信息
sudo chmod +x /var/packages/VideoStation/target/bin/ffmpeg
sudo chmod +s /var/packages/VideoStation/target/bin/ffmpeg
sudo chown root:VideoStation /var/packages/VideoStation/target/bin/ffmpeg

测试

这里有两个视频文件，分别时EAC3和DTS格式的视频文件，可以在DSM的FileStation中右击播放，查看是否成功。
EAC3：https://gofile.me/51V3S/WbIDHIvUU
DTS：https://gofile.me/51V3S/xp1jYf0W2

关于调试

通过脚本可知，本程序会将ffmpeg的日志输出到/tmp/ffmpeg.log文件中，有需要的可以查看。

附录1：ffmpeg-wrapper脚本内容

由于未知原因，在将ASS等格式的高级字幕转换成SRT格式字幕时，ffmpeg包所提供的ffmpeg可执行文件提示权限不足，导致字幕转换失败。在新版本的ffmpeg-wrapper利用VideoStation自带的ffmpeg可执行文件对字幕进行处理，从而ASS等高级字幕可以播放。由于PGS等图像格式的字幕无法转成文本格式，因此VideoStation不支持PGS等图像格式字幕。

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365

#!/bin/bash

rev="12"

_log(){
echo "$(date '+%Y-%m-%d %H:%M:%S') - ${streamid} - $1" >> /tmp/ffmpeg.log
}

_log_para(){
echo "$1" | fold -w 120 | sed "s/^.*$/$(date '+%Y-%m-%d %H:%M:%S') - ${streamid} -          = &/" >> /tmp/ffmpeg.log
}

_term(){
rm /tmp/ffmpeg-${streamid}.stderr
_log "*** KILLCHILD ***"
kill -TERM "$childpid" 2>/dev/null
}

trap _term SIGTERM

arch=`uname -a | sed 's/.*synology_//' | cut -d '_' -f 1`
nas=`uname -a | sed 's/.*synology_//' | cut -d '_' -f 2`
pid=$$
paramvs=$@
stream="${@: -1}"
streamid="FFM$pid"
bin1=/var/packages/ffmpeg/target/bin/ffmpeg
bin2=/var/packages/VideoStation/target/bin/ffmpeg-BACKUP
args=()

vcodec="KO"

while [[ $# -gt 0 ]]
do
case "$1" in
-i)
shift
movie="$1"
args+=("-i" "$1")
;;
-hwaccel)
shift
hwaccel="$1"
args+=("-hwaccel" "$1")
;;
-scodec)
shift
scodec="$1"
args+=("-scodec" "$1")
;;
-f)
shift
fcodec="$1"
args+=("-f" "$1")
;;
-map)
shift
args+=("-map" "$1")
idmap=`echo $1 | cut -d : -f 2`
if [ "$vcodec" = "KO" ]; then
vcodec=`/var/packages/ffmpeg/target/bin/ffprobe -v error -select_streams $idmap -show_entries stream=codec_name -of default=noprint_wrappers=1:nokey=1 "$movie" | head -n 1`
vcodecprofile=`/var/packages/ffmpeg/target/bin/ffprobe -v error -select_streams $idmap -show_entries stream=profile -of default=noprint_wrappers=1:nokey=1 "$movie" | head -n 1`
else
acodec=`/var/packages/ffmpeg/target/bin/ffprobe -v error -select_streams $idmap -show_entries stream=codec_name -of default=noprint_wrappers=1:nokey=1 "$movie" | head -n 1`
fi
;;
*)
args+=("$1")
;;
esac
shift
done

_log "*** PROCESS START REV $rev DS$nas ($arch) PID $pid ***"

streamdir=`dirname "$stream"`
device=`cat ${streamdir}/video_metadata | jq -r '.device'`
_log "DEVICE   = $device"
_log "MOVIE    = $movie"

set -- "${args[@]}"

argsnew=()
args1sv=()
args2sv=()
args1vs=()
args2vs=()

while [[ $# -gt 0 ]]
do
case "$1" in
-ss)
shift
argsnew+=("-ss" "$1")
args1sv+=("-ss" "$1")
args1sv+=("-noaccurate_seek")
args1vs+=("-ss" "$1")
args1vs+=("-noaccurate_seek")
args2sv+=("-analyzeduration" "10000000")
args2vs+=("-analyzeduration" "10000000")
;;
-i)
shift
argsnew+=("-i" "$1")
args1sv+=("-i" "$1")
args2sv+=("-i" "pipe:0" "-map" "0")
args1vs+=("-i" "$1")
args2vs+=("-i" "pipe:0" "-map" "0")
;;
-vf)
shift
if [ "$hwaccel" = "vaapi" ] && [ "$vcodecprofile" = "Main 10" ]; then
scale_w=`echo "${1}" | sed -e 's/.*=w=//g' | sed -e 's/:h=.*//g'`
scale_h=`echo "${1}" | sed -e 's/.*:h=//g'`
if let ${scale_w} AND let ${scale_h}; then
argsnew+=("-vf" "scale_vaapi=w=${scale_w}:h=${scale_h}:format=nv12,hwupload,setsar=sar=1")
else
argsnew+=("-vf" "scale_vaapi=format=nv12,hwupload,setsar=sar=1")
fi
else
argsnew+=("-vf" "$1")
fi
args2sv+=("-vf" "$1")
args1vs+=("-vf" "$1")
;;
-vcodec)
shift
argsnew+=("-vcodec" "$1")
args1sv+=("-vcodec" "copy")
args2sv+=("-vcodec" "$1")
args1vs+=("-vcodec" "$1")
args2vs+=("-vcodec" "copy")
;;
-acodec)
shift
if [ "$1" = "libfaac" ]; then
argsnew+=("-acodec" "aac")
args1sv+=("-acodec" "aac")
args2vs+=("-acodec" "aac")
else
argsnew+=("-acodec" "$1")
args1sv+=("-acodec" "$1")
args2vs+=("-acodec" "$1")
fi
args2sv+=("-acodec" "copy")
args1vs+=("-acodec" "copy")
;;
-ab)
shift
argsnew+=("-ab" "$1")
args1sv+=("-ab" "$1")
args2vs+=("-ab" "$1")
;;
-ac)
shift
argsnew+=("-ac" "$1")
args1sv+=("-ac" "$1")
args2vs+=("-ac" "$1")
;;
-f)
shift
argsnew+=("-f" "$1")
args1sv+=("-f" "mpegts")
args2sv+=("-f" "$1")
args1vs+=("-f" "mpegts")
args2vs+=("-f" "$1")
;;
-segment_format)
shift
argsnew+=("-segment_format" "$1")
args2vs+=("-segment_format" "$1")
args2sv+=("-segment_format" "$1")
;;
-segment_list_type)
shift
argsnew+=("-segment_list_type" "$1")
args2vs+=("-segment_list_type" "$1")
args2sv+=("-segment_list_type" "$1")
;;
-hls_seek_time)
shift
argsnew+=("-hls_seek_time" "$1")
args2vs+=("-hls_seek_time" "$1")
args2sv+=("-hls_seek_time" "$1")
;;
-segment_time)
shift
argsnew+=("-segment_time" "$1")
args2vs+=("-segment_time" "$1")
args2sv+=("-segment_time" "$1")
;;
-segment_time_delta)
shift
argsnew+=("-segment_time_delta" "$1")
args2vs+=("-segment_time_delta" "$1")
args2sv+=("-segment_time_delta" "$1")
;;
-segment_start_number)
shift
argsnew+=("-segment_start_number" "$1")
args2vs+=("-segment_start_number" "$1")
args2sv+=("-segment_start_number" "$1")
;;
-individual_header_trailer)
shift
argsnew+=("-individual_header_trailer" "$1")
args2vs+=("-individual_header_trailer" "$1")
args2sv+=("-individual_header_trailer" "$1")
;;
-avoid_negative_ts)
shift
argsnew+=("-avoid_negative_ts" "$1")
args2vs+=("-avoid_negative_ts" "$1")
args2sv+=("-avoid_negative_ts" "$1")
;;
-break_non_keyframes)
shift
argsnew+=("-break_non_keyframes" "$1")
args2vs+=("-break_non_keyframes" "$1")
args2sv+=("-break_non_keyframes" "$1")
;;
-max_muxing_queue_size)
shift
args2vs+=("-max_muxing_queue_size" "$1")
args2sv+=("-max_muxing_queue_size" "$1")
;;
-map)
shift
argsnew+=("-map" "$1")
args1sv+=("-map" "$1")
args1vs+=("-map" "$1")
;;
*)
argsnew+=("$1")
if [ "$stream" = "$1" ]; then
args1sv+=("-bufsize" "1024k" "pipe:1")
args2sv+=("$1")
args1vs+=("-bufsize" "1024k" "pipe:1")
args2vs+=("$1")
else
args2sv+=("$1")
args1vs+=("$1")
fi
;;
esac
shift
done

sed -i -e "s/{\"PID\":${pid},\"hardware_transcode\":true,/{\"PID\":${pid},\"hardware_transcode\":false,/" /tmp/VideoStation/enabled

startexectime=`date +%s`

if [ "$scodec" = "subrip" ]; then

_log "FFMPEG   = $bin2"
_log "CODEC    = $scodec"
_log "PARAMVS  ="
_log_para "$paramvs"

$bin2 "${args[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

elif [ "$fcodec" = "mjpeg" ]; then

_log "FFMPEG   = $bin2"
_log "CODEC    = $fcodec"
_log "PARAMVS  ="
_log_para "$paramvs"

$bin2 "${args[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

else

_log "VCODEC   = $vcodec ($vcodecprofile)"
_log "ACODEC   = $acodec"
_log "PARAMVS  ="
_log_para "$paramvs"
_log "MODE     = WRAP"
_log "FFMPEG   = $bin1"
_log "PARAMWP  ="
param1=${argsnew[@]}
_log_para "$param1"

$bin1 "${argsnew[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

fi

childpid=$!
_log "CHILDPID = $childpid"
wait $childpid

if grep "Conversion failed!" /tmp/ffmpeg-${streamid}.stderr || grep "Error opening filters!" /tmp/ffmpeg-${streamid}.stderr || grep "Unrecognized option" /tmp/ffmpeg-${streamid}.stderr || grep "Invalid data found when processing input" /tmp/ffmpeg-${streamid}.stderr; then

_log "*** CHILD END ***"
startexectime=`date +%s`
_log "STDOUT   ="
_log_para "`tail -n 15 /tmp/ffmpeg-${streamid}.stderr`"
_log "MODE     = PIPE SV"
_log "FFMPEG1  = $bin1"
_log "FFMPEG2  = $bin2"
_log "PARAM1   ="
param1=${args1sv[@]}
_log_para "$param1"
_log "PARAM2   ="
param2=${args2sv[@]}
_log_para "$param2"

$bin1 "${args1sv[@]}" | $bin2 "${args2sv[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

childpid=$!
_log "CHILDPID = $childpid"
wait $childpid

fi

if grep "Conversion failed!" /tmp/ffmpeg-${streamid}.stderr || grep "Error opening filters!" /tmp/ffmpeg-${streamid}.stderr || grep "Unrecognized option" /tmp/ffmpeg-${streamid}.stderr || grep "Invalid data found when processing input" /tmp/ffmpeg-${streamid}.stderr; then

_log "*** CHILD END ***"
startexectime=`date +%s`
_log "STDOUT   ="
_log_para "`tail -n 15 /tmp/ffmpeg-${streamid}.stderr`"
_log "MODE     = PIPE VS"
_log "FFMPEG1  = $bin2"
_log "FFMPEG2  = $bin1"
_log "PARAM1   ="
param1=${args1vs[@]}
_log_para "$param1"
_log "PARAM2   ="
param2=${args2vs[@]}
_log_para "$param2"

$bin2 "${args1vs[@]}" | $bin1 "${args2vs[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

childpid=$!
_log "CHILDPID = $childpid"
wait $childpid

fi

if grep "Conversion failed!" /tmp/ffmpeg-${streamid}.stderr || grep "Error opening filters!" /tmp/ffmpeg-${streamid}.stderr || grep "Unrecognized option" /tmp/ffmpeg-${streamid}.stderr || grep "Invalid data found when processing input" /tmp/ffmpeg-${streamid}.stderr; then

_log "*** CHILD END ***"
startexectime=`date +%s`
_log "STDOUT   ="
_log_para "`tail -n 15 /tmp/ffmpeg-${streamid}.stderr`"
_log "MODE     = ORIG"
_log "FFMPEG   = $bin2"

$bin2 "${args[@]}" &> /tmp/ffmpeg-${streamid}.stderr &

childpid=$!
_log "CHILDPID = $childpid"
wait $childpid

fi

stopexectime=`date +%s`
if test $((stopexectime-startexectime)) -lt 10; then
_log "STDOUT   ="
_log_para "`tail -n 15 /tmp/ffmpeg-${streamid}.stderr`"
fi

_log "*** CHILD END ***"
_log "*** PROCESS END ***"

rm /tmp/ffmpeg-${streamid}.stderr

附录2：原ffmpeg-wrapper脚本内容(已经弃用)

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

#!/bin/bash

bin="exec /var/packages/ffmpeg/target/bin/ffmpeg"

# DEBUG
echo "$@" >> /tmp/ffmpeg.log

args=()
while [[ $# -gt 0 ]]
do
case "$1" in
    -vprofile)
       shift
       args+=("-x264profile" "$1")
       ;;
    -vf)
       shift
       #vf=$(echo "$1" | sed -e 's/format=nv12.*scale_vaapi/scale_vaapi/g' -e 's/$/:format=nv12/')
           # DEBUG
       vf=$(echo "$1" | tee -a /tmp/ffmpeg.log | sed -e 's/format=nv12.*scale_vaapi/scale_vaapi/g' -e 's/$/:format=nv12/
')
           echo "vf: [$vf]" >> /tmp/ffmpeg.log
       args+=("-vf" "$vf")
       ;;
    -i)
       shift
       movie="$1"
       args+=("-i" "$1")
       # DEBUG
       echo "movie=[$movie]" >> /tmp/ffmpeg.log
       ;;
    *)
       args+=("$1")
       ;;
esac
shift
done

set -- "${args[@]}"

# DEBUG
echo $bin "$@" >> /tmp/ffmpeg.log
echo >> /tmp/ffmpeg.log
$bin "$@" 2>>/tmp/ffmpeg.log

#$bin "$@"

安装依赖

1
2
3
4
5
6
7
8

sudo apt install 
            automake \
            gcc \
            g++ \
            libtool \
            pkg-config \
            libcrypto++-dev \
            libssl-dev

下载源代码并解压

1
2

wget http://rtorrent.net/downloads/libtorrent-0.13.8.tar.gz
tar zxvf libtorrent-0.13.8.tar.gz

编译安装

1
2
3
4
5

cd libtorrent-0.13.8
./autogen.sh
./configure
make -j4
sudo make install

rTorrent

安装依赖

1
2
3
4
5

sudo apt install 
            libncurses-dev \
            libxmlrpc-core-c3-dev \
            libcurl4-openssl-dev \
            libcurlpp-dev

下载源代码并解压

1
2

wget http://rtorrent.net/downloads/rtorrent-0.9.8.tar.gz
tar zxvf rtorrent-0.9.8.tar.gz

编译安装

1
2
3
4
5

cd rtorrent-0.9.8
./autogen.sh
./configure --with-xmlrpc-c --with-libcurl
make -j4
sudo make install

rTorrent配置文件

rTorrent的配置文件在~/.rtorrent.rc，在启动前，需要对rTorrent进行相关的配置，下面是我的配置，仅供参考。具体配置的相关教程请参考rTorrent配置文件

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#############################################################################
# A minimal rTorrent configuration that provides the basic features
# you want to have in addition to the built-in defaults.
#
# See https://github.com/rakshasa/rtorrent/wiki/CONFIG-Template
# for an up-to-date version.
#############################################################################


## Instance layout (base paths)
method.insert = cfg.basedir,  private|const|string, (cat,"/home/rtorrent/rtorrent/")
method.insert = cfg.download, private|const|string, (cat,"/mnt/download/")
method.insert = cfg.logs,     private|const|string, (cat,(cfg.basedir),"log/")
method.insert = cfg.logfile,  private|const|string, (cat,(cfg.logs),"rtorrent-",(system.time),".log")
method.insert = cfg.session,  private|const|string, (cat,(cfg.basedir),".session/")
method.insert = cfg.watch,    private|const|string, (cat,(cfg.basedir),"watch/")


## Create instance directories
execute.throw = sh, -c, (cat,\
    "mkdir -p \"",(cfg.download),"\" ",\
    "\"",(cfg.logs),"\" ",\
    "\"",(cfg.session),"\" ",\
    "\"",(cfg.watch),"/load\" ",\
    "\"",(cfg.watch),"/start\" ")


## Listening port for incoming peer traffic (fixed; you can also randomize it)
network.port_range.set = 50000-50000
network.port_random.set = no

## Tracker-less torrent and UDP tracker support
## (conservative settings for 'private' trackers, change for 'public')
dht.mode.set = disable
protocol.pex.set = no

trackers.use_udp.set = yes


## Peer settings
throttle.max_uploads.set = 100
throttle.max_uploads.global.set = 250

throttle.global_up.max_rate.set = 131072
throttle.global_down.max_rate.set = 2097152

throttle.min_peers.normal.set = 20
throttle.max_peers.normal.set = 60
throttle.min_peers.seed.set = 30
throttle.max_peers.seed.set = 80
trackers.numwant.set = 80

protocol.encryption.set = allow_incoming,try_outgoing,enable_retry


## Limits for file handle resources, this is optimized for
## an `ulimit` of 1024 (a common default). You MUST leave
## a ceiling of handles reserved for rTorrent's internal needs!
network.http.max_open.set = 50
network.max_open_files.set = 600
network.max_open_sockets.set = 300


## Memory resource usage (increase if you have a large number of items loaded,
## and/or the available resources to spend)
pieces.memory.max.set = 4096M
network.xmlrpc.size_limit.set = 2M


## Basic operational settings (no need to change these)
session.path.set = (cat, (cfg.session))
directory.default.set = (cat, (cfg.download))
log.execute = (cat, (cfg.logs), "execute.log")
log.xmlrpc = (cat, (cfg.logs), "xmlrpc.log")
execute.nothrow = sh, -c, (cat, "echo >",\
    "/tmp/rtorrent.pid", " ",(system.pid))


## Other operational settings (check & adapt)
encoding.add = utf8
system.umask.set = 0027
system.cwd.set = (directory.default)
network.http.dns_cache_timeout.set = 25
schedule2 = monitor_diskspace, 15, 60, ((close_low_diskspace, 1000M))
#pieces.hash.on_completion.set = no
#view.sort_current = seeding, greater=d.ratio=
#keys.layout.set = qwerty
#network.http.capath.set = "/etc/ssl/certs"
#network.http.ssl_verify_peer.set = 0
#network.http.ssl_verify_host.set = 0


## Some additional values and commands
method.insert = system.startup_time, value|const, (system.time)
method.insert = d.data_path, simple,\
    "if=(d.is_multi_file),\
        (cat, (d.directory), /),\
        (cat, (d.directory), /, (d.name))"
method.insert = d.session_file, simple, "cat=(session.path), (d.hash), .torrent"


## Watch directories (add more as you like, but use unique schedule names)
## Add torrent
schedule2 = watch_load, 11, 10, ((load.verbose, (cat, (cfg.watch), "load/*.torrent")))
## Add & download straight away
schedule2 = watch_start, 10, 10, ((load.start_verbose, (cat, (cfg.watch), "start/*.torrent")))


## Run the rTorrent process as a daemon in the background
## (and control via XMLRPC sockets)
system.daemon.set = false
#network.scgi.open_local ="/tmp/rpc.socket"
#execute.nothrow = chmod,770,"/tmp/rpc.socket"
scgi_port = 127.0.0.1:5000

## Logging:
##   Levels = critical error warn notice info debug
##   Groups = connection_* dht_* peer_* rpc_* storage_* thread_* tracker_* torrent_*
print = (cat, "Logging to ", (cfg.logfile))
log.open_file = "log", (cfg.logfile)
log.add_output = "notice", "log"
#log.add_output = "tracker_debug", "log"

### END of rtorrent.rc ###

配置自动启动

将下方内容写入/etc/systemd/system/rtorrent.service，然后可以使用systemd在后台启动rtorrent，并可以通过tmux a -t rtorrent查看rtorrent的运行状态。

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

[Unit]
Description=rTorrent
Wants=network-online.target
After=network-online.target

[Service]
User=rtorrent
Group=rtorrent
Type=forking
PIDFile=/tmp/rtorrent.pid
ExecStart=/usr/bin/tmux new-session -s rtorrent -d /usr/local/bin/rtorrent
ExecStop=/usr/bin/tmux send-keys -t rtorrent C-q

[Install]
WantedBy=multi-user.target

Flood-UI

Flood-UI是一个现代化的rTorrent界面，用户可以使用web查看、操作rTorrent。

安装依赖

安装依赖需要注意，Ubuntu包管理中的nodejs版本比较低，若想使用最新版本的nodejs，请参考以下链接进行安装：NodeJS安装教程

1
2
3
4
5
6
7
8
9

# 配置安装nodejs 13.x
curl -sL https://deb.nodesource.com/setup_13.x | sudo -E bash -
sudo apt-get install -y nodejs

# 安装其他依赖
sudo apt install \
            git \
            node-gyp \
            mediainfo

下载源代码

1

git clone https://github.com/Flood-UI/flood.git

编译安装

1
2
3
4
5

cd flood
npm install
cp config.template.js config.js
vim config.js # 根据需要编辑配置文件
npm run-script build

启动flood

Flood-UI的默认地址为127.0.0.1:3000，如果需要修改，请在config.js中配置。

1

npm start

运行命令后，在浏览器访问127.0.0.1:3000，之后再网页中配置用户名及密码，rtorrent的cgi地址默认是127.0.0.1:5000，改配置在~/.rtorrent.rc中配置。

1

git config --global credential.helper store

如果只想保存某个仓库的用户名密码信息，可以去掉--global参数。

需要注意的是，该密码是明文存储，保存在~/.git-credentials文件中。
该文件内容类似于一下方式：

1

https://user:pass@example.com

文本 $\Rightarrow$ 日期

可以使用DATE(year, month, day)函数来实现，具体如下：

结果为：

备注：

• LEFT(text, [num_chars])表示从text中选取最__左侧__的num_chars个字符。
• RIGHT(text, [num_chars])表示从text中选取最__右侧__的num_chars个字符。
• MID(text, start_num, num_chars)表示从start_num开始返回num_chars个字符。
• 可以点击这里查看关于__DATE函数__的更多用法。

日期 $\Rightarrow$ 文本

可以使用TEXT(text, format)函数来实现，具体如下：

结果为：

备注：可以点击这里查看关于TEXT函数的更多用法。

日期计算

加减月份

使用EDATE(start_date, months)函数可以计算某个日期(start_date)之前、之后几个月的日期。

结果为：

备注：

• 要求start_date必须是日期，如果不是日期，可以通过这里进行转换。
• EDATE的输出也是日期格式。
• 可以点击这里查看关于EDATE函数的更多用法。

Cache的缺失主要分为强制缺失(Compulsory Miss)**、容量缺失(Capacity Miss)以及冲突缺失(Conflict Miss)，其中，强制缺失又称为冷缺失(Cold Miss)**。

概念

• 强制缺失：CPU第一次访问相应Cache块，Cache中肯定没有该Cache块，引起的缺失叫做强制缺失。这是不可避免的。
• 容量缺失：有限的Cache容量导致Cache放不下而替换出Cache块，被替换出去的Cache块再被访问，引起的失效叫做容量失效。
• 冲突缺失：在直接相联或组相联的Cache中，不同的Cache块由于Index相同相互替换，引起的失效叫做冲突失效。

强制缺失

在Cache的三种缺失中，强制缺失非常好区分，只要是CPU第一次访问相应的Cache块引起的缺失，就称作强制缺失。

容量缺失

在直接映射或组相联Cache的情况下，若该Cache行被替换出去时，Cache已经满了，就是容量缺失。

举一个例子说明一下：
如果有一个64KB大小的数组需要重复访问，而Cache大小只有16KB，这时数组的大小远远大于Cache大小，没办法全部放入Cache。第一次访问数组发生的失效是强制缺失。而之后再访问数组，再发生的缺失则全都是容量缺失，这时Cache已经存满，容量不足以存储全部数据。

冲突缺失

在直接映射或组相联Cache的情况下，若该Cache行被替换出去时，还有其他空闲的Cache行，则是冲突缺失。

同样也举一个例子说明：
如果有两个8KB大小的数据需要来回访问，但是这两个数组都映射到相同的地址，Cache的大小为16KB，足够存储全部的数据，但是因为相同地址发生了冲突需要来回替换，发生的缺失则全都是冲突缺失（第一次访问失效依旧是强制缺失），这时Cache并没有存满。

降低Cache缺失的方法

• 强制缺失：无法避免。
• 容量缺失：增加Cache大小。
• 冲突缺失：增加Cache相联度、优化替换策略、增大Cache大小等等。

设计并实现用于列车售票的可线性化并发数据结构。

实验说明

给定Ticket类：

1
2
3
4
5
6
7
8
9

class Ticket {
    long tid;           // 车票编号
    String passenger;   // 乘客名字
    int route;          // 列车车次
    int coach;          // 车厢号
    int seat;           // 座位号
    int departure;      // 出发站编号
    int arrival;        // 到达站编号
}

给定TicketingSystem接口：

1
2
3
4
5
6
7
8

public interface TicketingSystem {
    // 买票，即乘客passenger购买route车次从departure站到arrival站的车票一张。若购买成功，返回有效的Ticket对象；若失败(无余票)，则返回null
    Ticket buyTicket(String passenger, int route, int departure, int arrival);
    // 查询余票，即查询route车次从departure站到arrival站的余票数
    int inquiry(int route, int departure, int arrival);
    // 退票，对有效的Ticket对象返回true，对无效的Ticket返回false
    boolean refundTicket(Ticket ticket);
}

给定TicketingDS类的构造器接口：

1

TicketingDS(routenum, coachnum, seatnum, stationnum, threadnum)

其中：route是车次总数（缺省为5），coachnum是列车车厢数目（缺省为8），seatnum是每节车厢的座位数（缺省为100），stationnum是每个车次经停站数量（缺省为10，含始发站和终点站），threadnum是并发购票的线程数（缺省为16）。

说明：

为简单起见，假设每个车次的coachnum、seatnum和stationnum都相同。车票涉及的各项参数均从1开始计数，例如车厢从1到8编号，车站从1到10编号等。

系统中同时存在threadnum个线程（缺省为16），每个线程是一个票务代理，按照60%**查询余票，30%购票和10%**退票的比率反复调用TicketingDS类的三种方法若干次（缺省为每个线程10000次）。按照线程数为4、8、16、32、64个的情况，分别给出每种方法调用的平均执行时间，同时计算系统的总吞吐率（单位时间内完成的方法调用总数）。

正确性要求

• 每张车票都有一个唯一的你编号tid，不能重复。
• 每一个tid的车票只能出售一次。退票后，原车票的tid作废。
• 每个区段有余票时，系统必须满足该区段的购票请求。
• 车票不能超卖，系统不能卖无座车票。
• 查询结果允许不精确，但是在某个车次查票过程中没有其他购票和退票的“静止”状态下，该车次查询余票的结果必须准确。

设计思路

设计思路按照并发程序的基本设计思路来逐步实现。

设计并发程序的基本思路分别是粗粒度锁、细粒度锁、乐观锁和**无锁(lock-free)**四个阶段。这四个阶段的难度也逐步递增，基本上来说，达到乐观锁的性能就已经不错了。

特别感谢王鹿鸣同学提供的部分优化思路。

粗粒度锁(Coarse-lock)

主要数据结构

1
2
3
4
5
6
7

public class Train {
    public boolean[][] coachs;  // 表示车座状态
    public int seatNum;         // 表示列车座位的总数
    public int coachNum;        // 表示车厢数
    public int stationNum;      // 表示车站数目
    private ReentrantLock lock; // 列车锁，可重入锁
}

说明：用一个二维数组表示列车每个座位以及座位在每站之间的使用情况。coachs[i][j] == false表示火车的第i个座位在第j到j+1站之间，没有卖出。

思路

由于列车之间没有相关性，因此，可以给每个火车一把锁。
当购票和查询时，先获得该列车的锁，然后再遍历数组，修改某个座位的状态，最后释放锁。
由于退票不需要遍历数组，但是，依然要先获得锁，再修改座位的状态，最后释放锁。

需要注意的是，在修改座位状态时，一定要确认，修改前的状态是否符合你的预期，这样才能保证程序的正确性；若不符合，应返回false。如果没有验证座位的状态，会出现车票超售或者退票失败的情况。

细粒度锁(Fine-lock)

主要数据结构

1
2
3
4
5
6
7

public class Train {
    public boolean[][] coachs;
    public int seatNum;
    public int coachNum;
    public int stationNum;
    private ReentrantLock[] locks;
}

与粗粒度锁相比，增加了锁的数量，每个座位有自己的一把锁。

思路

将锁进一步细化，给火车的每一个座位设置一把锁。
当遍历coachs数组时，要先获得该座位的锁，然后再去访问该座位的内容。
由于使用的是数组存储，因此不需要交叉手这样的方式加锁。

与粗粒度锁一样，在修改状态前，也要检查座位的状态是否符合预期。

乐观锁(Optimistic-lock)

主要数据结构

乐观锁的数据结构与细粒度锁一致。

思路

乐观锁认为，在对共享变量操作时，乐观的认为，读操作与写操作同时发生的概率非常小，因此，在读取变量时不需要加锁。
因此，乐观锁的退票与细粒度锁一样，不需要修改。而在查询操作中，完全不加锁，直接遍历一遍。

在购票过程中，在遍历数组时，不需要获得锁，只有在找到合适的、符合要求的未出售的座位时，才尝试获得锁。
获得锁后，一定要再次确认座位的状态是否符合预期。因为，在加锁过程中原本符合预期的状态，可能被其他线程修改了。因此要再次确认！

改进思路

由于座位在每个站的状态使用boolean数组表示的，因此，可以尝试改用BitSet来表示。

无锁(Lock-free)

主要数据结构

1
2
3
4
5
6

public class Train {
    public AtomicBitSet[] coachs;
    public int seatNum;
    public int coachNum;
    public int stationNum;
}

思路

由乐观锁的改进思路演化而来，将座位设置成原子对象(Atomic)，在修改车座状态时，通过CAS(CompareAndSet)方法操作。

由于车站数量不会过多，即stationnum < 64，所以，可以使用一个Long代替BitSet。
通过自己编写AtomicBitSet，减轻额外负担，可以提高性能。

改进思路

为了防止伪共享，可以在AtomicBitSet后面添加padding，使得一个Cache Line中只有一个AtomicLong对象，降低Cache的乒乓效应。

对已售车票的保存

• ConcurrentLinkedDeque链表存储已售车票。但是发现在无锁结构下，该链表成为瓶颈。

• ConcurrentHashMap存储已售车票，由于Hash表结构非常适合并发进程，因此，性能得到提升。
  PS: ConcurrentHashMap的contains(key)方法的效率远高于containsValue(value)方法。

实验代码

代码地址：https://gitee.com/873314461/ticketing-system

正确性分析

车票编号tid

车票的id使用一个AtomicInteger实现，保证了多个线程同时调用getAndIncrement()时，tid不会重复。

买票的正确性

在买票时，遍历车座，比较每一个座位是否符合购票条件，若符合条件，则锁定座位，并出票；否则返回null。

• 粗粒度锁：保证每列火车只有一个线程在买票、退票或者查询，因此，不会出现超售或者有座位但不出票的情况。
• 细粒度锁：保证每个座位只有一个线程在买票、退票或者查询，每个座位的状态在某个时刻是唯一的，保证正确性。
• 乐观锁：保证每个座位只有一个线程在买票或者退票，由于读操作不会修改座位状态，并且，加锁后会再次确认状态，因此，在修改时，每个座位的状态是确定的，从而保证正确性。
• 无锁：通过CAS方式，保证每个座位状态修改时，都是符合期望的，从而保证正确性。

查询车票的静态一致性

在车票查询过程中，只需要保证静态一致性即可。

静态一致性要求：由一系列静止状态分隔开的方法调用应呈现出与按照它们的实时调用次序相同的执行效果。

因此只要保证处于静止状态时，统计的车票数是准确的即可。因此，可以直接遍历数组，判断每一个座位的状态即可保证静态一致性。

性能分析

测试环境

使用老师提供的服务器：80核、160线程、256GB内存，单核1.0GHz，jdk 1.7。

共有5个车次，每个车次10个站点（包括始发站和终点站），每趟列车8个车厢，每节车厢100个座位。

买票、退票和查询的比例为：30%、10%和60%。

方法调用总次数为：线程数(threadnum) * 1000000。

结论

整体来看，无锁(Lock-Free) > 乐观锁(Optimistic-Lock) > 粗粒度锁(Coarse-Lock) > 细粒度锁(Fine-Lock)。
吞吐量如图所示：

在通常情况下，细粒度锁的吞吐量效果应该优于粗粒度锁的，但是因为本题目数据结构的特殊性（数组），使得粗粒度锁的效果优于细粒度锁。

这种现象与链表相似，由于在遍历数组时，每一步都要加锁，会阻塞后面的线程，无法超车，所有线程排队遍历数组，导致效率降低；又因为加锁的额外开销，导致性能低于粗粒度锁。

对于买票、退票和查询的时间对比如下：

我们发现，对于粗粒度锁和细粒度锁(退票方法除外)来说，方法调用的耗时基本上与线程数成线性关系。

粗粒度锁

细粒度锁

乐观锁

无锁

其他分析

结论

在买票和退票中，都是Linearizability、Lock-Free的。但是在LockFree实现中的买票和退票方法，因为使用了CAS操作，可能存在某个倒霉的线程，每次CAS操作都被别的打断，因此不是Starvation-Free和Wait-Free。

在查票方法中，只有粗粒度锁的实现中是Linearizability，其他的方法中，都只符合静态一致性。
但是，查询方法是可以达到线性化的，只需要在每次查询前，对数组做快照，就可以实现线性化的查询方法。
该方法会导致查询耗时和内存急剧增长，在没有严格要求查询满足线性化时，尽量不要使用这种方法。

买票

退票

查询

修改记录

2017.12.20 增加改进思路，提高对Cache Line的亲和性，并降低函数调用层次。
2018.01.05 增加正确性分析和性能分析。

给定网络拓扑以及节点的网络地址配置（包含私网地址），实现NAT地址转换功能，使得左侧的私网H1节点能够连接H2节点并传输数据

实验拓扑

实验内容

1. 运行给定网络拓扑(nat_topo.py)

1

sudo python2 topo/nat_topo.py

2. 在n1中启动NAT服务

1
2
3
4
5
6

./scripts/disable_arp.sh
./scripts/disable_icmp.sh
./scripts/disable_ip_forward.sh # Archlinux中需要将-p ip改成-p ipv4
./scripts/disable_tcp_rst.sh
export LD_LIBRARY_PATH=.;       # 设置lib路径
./nat                           # 启动NAT服务

3. 在h2节点启动简易HTTP服务器

1
2

./scripts/disable_offloading.sh # 防止协议栈生成错误的checksum
python2 -m SimpleHTTPServer

4. 在h1节点启动wget请求h2

1
2

./scripts/disable_offloading.sh # 防止协议栈生成错误的checksum
wget http://159.226.39.123:8000

主要数据结构

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

struct nat_connection {
u8 internal_fin;// indicates whether received fin packet from inner node
u8 external_fin;// indicates whether received fin packet from outer node

u32internal_seq_end;// the highest sequence number transmitted by inner node
u32external_seq_end;// the highest sequence number transmitted by outer node

u32 internal_ack;// the highest sequence number acked by inner node
u32 external_ack;// the highest sequence number acked by outer node
};

// the mapping entry used for address translation
struct nat_mapping {
struct list_head list;

u32 internal_ip;// ip address seen in private network
u32 external_ip;// ip address seen in public network (the ip address of external interface)
u16 internal_port;// port seen in private network
u16 external_port;// port seen in public network (assigned by nat)

time_t update_time;// when receiving the latest packet
struct nat_connection conn;// statistics of the tcp connection
};

实验过程

本实验老师已经给了框架，只需要将几个函数的功能实现就可以了。所以这里只介绍每个函数的功能，具体实现见源代码。

代码地址：https://gitee.com/873314461/nat_stack

is_flow_finished

这个函数主要是判断TCP流有没有结束，如果TCP两端均发送了FIN报文且seq_end与ack相等，则证明TCP流已经结束了。

即同时满足以下4个条件时，TCP流已经结束。

1
2
3
4

internal_fin == true
external_fin == true
internal_seq_end == external_ack
external_seq_end == internal_ack

nat_lookup_external

这个函数是通过external_port在mapping_list中查找对应的nat_mapping对象。

只需要遍历整个链表，找到external_port相等的节点返回即可。

nat_lookup_internal

与上个函数作用类似，只是通过internal_ip和internal_port在mapping_list中查找对应的nat_mapping对象。

assign_external_port

分配一个未使用的external_port。

只需要遍历端口池(nat.assigned_ports)，若nat.assigned_ports[port]为0，则将其置为1，则返回port。

free_port

释放一个端口。

将nat.assigned_ports[port]置为0。

nat_insert_mapping

创建一个nat_mapping对象，并将其插入到hash表中。

需要：

1. 申请内存。
2. 初始化相应信息。
3. 插入到list中。
4. 并将nat_mapping指针返回。

get_packet_direction

这个函数主要是通过packet的内容，判断这个报文的传送方向是DIR_IN还是DIR_OUT。

判断方法是，用packet的目的IP查找路由表，得到相应的iface。若iface与internal_iface相同，则方向为DIR_IN;若iface与external_iface相同，则方向为DIR_OUT。

具体方法如下：

1. 将packet解析。
2. 根据目的IP查找路由表。
3. 比较iface，并返回结果。

nat_update_tcp_connection

这个函数用来更新nat_mapping对象中的tcp信息。包括：最后连接时间(update_time)和nat_connection对象。

1. 解析packet。
2. 计算TCP报文的seq_end。
3. 更新update_time。
4. 更新nat_connection对象。

PS: 注意网络序与主机序的转换！

nat_get_mapping_from_packet

通过packet在nat_mapping_list中查找对应的nat_mapping对象。

若报文方向为DIR_IN，则通过external查找。

若报文方向为DIR_OUT，则通过internal查找。

do_translation

这个函数是NAT实验的核心函数。实现真正的包转发。

1. 根据(server_ip, server_port)计算hash
2. 查找packet所对应的nat_mapping对象。
3. 若未找到nat_mapping对象，且传输方向为DIR_OUT，则插入到nat_mapping_list中。
4. 修改packet的源、目的IP地址和端口。
5. 重新计算TCP和IP的checksum。
6. 更新nat_mapping对象中的TCP信息。
7. 将报文发送出去。

nat_timeout

这是一个单独运行的线程，用来关闭并回收已经结束的或者超时的TCP流的nat_mapping对象。

每隔一定时间，遍历整个nat_mapping_list，将超时的或者已经结束的nat_mapping对象移除，并释放资源。

PS：遍历list时，一定要使用list_for_each_entry_safe这个循环，只有在这个循环中，才可以对list进行插入或者删除节点的操作。

实验感悟

• 了解了NAT的工作原理。

给定网络拓扑和节点配置，节点实现TCP最基本的连接管理和数据传输功能，使得节点之间能够在无丢包网络环境中传输数据。

实验拓扑

实验内容

1. 运行给定网络拓扑(tcp_topo.py)

   1	sudo python2 topo/tcp_topo.py

2. 在节点h1上执行TCP程序

   执行脚本，禁止协议栈的相应功能，并在h1上运行TCP协议栈的服务器模式。

   1 2 3 4 5 6

   ./scripts/disable_arp.sh ./scripts/disable_icmp.sh ./scripts/disable_ip_forward.sh ./scripts/disable_tcp_rst.sh export LD_LIBRARY_PATH=.; ./tcp_stack server 10001

3. 在节点h2上执行TCP程序

   执行脚本，禁止协议栈的相应功能，并在h2上运行TCP协议栈的客户端模式，连接h1并从h1正确获得数据。

   1 2 3 4 5 6

   ./scripts/disable_arp.sh ./scripts/disable_icmp.sh ./scripts/disable_ip_forward.sh ./scripts/disable_tcp_rst.sh export LD_LIBRARY_PATH=.; ./tcp_stack client 10.0.0.1 10001

   主要数据结构

   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 65 66 67 68 69 70 71 72 73

   //socket 对象 struct tcp_sock { // sk_ip, sk_sport, sk_sip, sk_dport are the 4-tuple that represents a // connection struct sock_addr local; struct sock_addr peer; #define sk_sip local.ip #define sk_sport local.port #define sk_dip peer.ip #define sk_dport peer.port // pointer to parent tcp sock, a tcp sock which bind and listen to a port // is the parent of tcp socks when *accept* a connection request struct tcp_sock *parent; // represents the number that the tcp sock is referred, if this number // decreased to zero, the tcp sock should be released int ref_cnt; // hash_list is used to hash tcp sock into listen_table or established_table, // bind_hash_list is used to hash into bind_table struct list_head hash_list; struct list_head bind_hash_list; // when a passively opened tcp sock receives a SYN packet, it mallocs a child // tcp sock to serve the incoming connection, which is pending in the // listen_queue of parent tcp sock struct list_head listen_queue; // when receiving the last packet (ACK) of the 3-way handshake, the tcp sock // in listen_queue will be moved into accept_queue, waiting for *accept* by // parent tcp sock struct list_head accept_queue; #define TCP_MAX_BACKLOG 128 // the number of pending tcp sock in accept_queue int accept_backlog; // the maximum number of pending tcp sock in accept_queue int backlog; // the list node used to link listen_queue or accept_queue of parent tcp sock struct list_head list; // tcp timer used during TCP_TIME_WAIT state struct tcp_timer timewait; // async waiting structure of *connect*, *accept*, *recv*, and *send* struct synch_wait *wait_connect; struct synch_wait *wait_accept; struct synch_wait *wait_recv; struct synch_wait *wait_send; // receiving buffer struct ring_buffer *rcv_buf; // tcp state, see enum tcp_state in tcp.h int state; // initial sending sequence number u32 iss; // the highest byte that is ACKed by peer u32 snd_una; // the highest byte sent u32 snd_nxt; // the highest byte ACKed by itself (i.e. the byte expected to receive next) u32 rcv_nxt; // the size of sending window (i.e. the receiving window advertised by peer) u16 snd_wnd; // the size of receiving window (advertised by tcp sock itself) u16 rcv_wnd; };

TCP状态转移图

TCP建立连接状态转移图

TCP断开连接状态转移图

实验过程

本实验老师已经给了框架，只需要将几个函数的功能实现就可以了。所以这里只介绍每个函数的功能，具体实现见源代码。

代码地址：https://gitee.com/873314461/tcp_stack

tcp_state_listen

这个函数是用来处理处于TCP_LISTEN状态的socket。

处于监听状态的ServerSocket，在收到第一个SYN报文时，将会：

1. 生成一个新的子socket，并将子socket的parent指向原来的ServerSocket。
2. 将子socket插入到原ServerSocket的listen_queue队列中。
3. 用子socket发送SYN|ACK报文。(TCP连接的第二次握手)
4. 将子socket的状态置为TCP_SYN_RECV，并将子socket插入到established_table中——因为这时区分TCP连接的四元组(saddr, daddr, sport, dport)已经确定了。

tcp_state_syn_sent

这个函数是用来处理处于TCP_SYN_SENT状态的socket。当客户端发出第一个SYN报文之后，就会处于这个状态。

在这个状态，需要处理一下内容：

1. 判断这个收到的报文，是否是SYN|ACK报文，如果不是，回复RST报文并结束。
2. 如果收到的报文正常，则需要回复ACK报文。(TCP第三次握手)
3. 将socket转换为TCP_ESTABLISHED状态，并加入到established_table中。
4. 唤醒阻塞于tcp_sock_connect的进程。

tcp_state_syn_recv

这个函数是用来处理处于TCP_SYN_RECV状态的socket。当服务器收到客户端发来的第一个SYN报文，并且回复了SYN|ACK报文后，处于这个状态。

在这个状态将要：

1. 将socket从原ServerSocket的listen_queue队列中移除。
2. 将socket插入到原ServerSocket的accept_queue队列中。
3. 将socket的状态置为TCP_ESTABLISHED。
4. 唤醒处于tcp_accpet的进程，即：唤醒原ServerSocket的wait_accept对象。

tcp_recv_data

这个函数用来接收报文发送的数据，并将数据送到socket的环形缓冲区(rcv_buf)中。

1. 将报文的负载写入到环形缓冲区中。
2. 唤醒正在等待接收消息的进程，即：socket的wait_recv对象。

tcp_process

这个函数是处理接收到的TCP报文的主函数。根据各种不同的状态，选择合适的策略，处理报文。在理解这个函数过程中，请全程参考TCP状态转移图。

1. 如果socket处于TCP_CLOSED状态，则交给tcp_state_closed函数处理。
2. 如果socket处于TCP_LISTEN状态，则交给tcp_state_listen函数处理。
3. 如果socket处于TCP_SYN_SENT状态，则交给tcp_state_syn_sent函数处理。
4. 调用is_tcp_seq_valid函数验证报文的序列号是否正确，若不正确，丢弃这个包
5. 若RST为1，则关闭这个连接，并释放这个连接的资源。因为RST表示连接重置，这个连接已经不再使用了。
6. 若SYN为1，则回复RST，并关闭这个连接。因为正常的SYN连接，已经在第2、3步处理过了。
7. 若ACK为0，则丢弃这个包。因为除了第一个SYN报文之外，所有的报文的ACK都应该为1。(需要实验验证一下)
8. 如果socket处于TCP_SYN_RECV状态，调用tcp_state_syn_recv函数处理。
9. 如果socket处于TCP_FIN_WAIT_1，则将socket状态转换到TCP_FIN_WAIT_2状态。
10. 如果socket处于TCP_LAST_ACK，则将socket状态转换到TCP_CLOSED状态，并从established_table中移除，并释放资源。
11. 如果socket处于TCP_FIN_WAIT_2状态，则需要判断收到的报文是否是FIN|ACK报文：若是，则回复ACK报文，并启动定时器；否则，丢弃这个包。
12. 如果接收的报文确认了发送的报文，则更新窗口大小。
13. 若报文有负载数据，则接收数据。
14. 若FIN为1，则将socket状态转变到TCP_CLOSE_WAIT状态，并回复ACK报文，表名接收到FIN报文。发送FIN|ACK报文，请求关闭这个连接，并将socket状态置为TCP_LAST_ACK。
15. 若前面没有返回，则应当发送ACK报文，确认当前接收的报文。

PS: 本函数的逻辑可能存在问题，需要再考虑一下。

alloc_tcp_sock

这个函数是创建一个tcp_sock对象，但是根据函数名，我认为这个函数应当只申请内存，并不进行初始化，但是，我在头文件中没有找到初始化函数，因此只能在这个函数中，对tcp_sock对象进行初始化。

1. 申请内存。
2. 初始化两个队列：listen_queue和accept_queue。
3. 初始化四个等待对象：wait_accept、wait_connect、wait_recv和wait_send
4. 初始化发送序列号以及发送、接收窗口大小。
5. 初始化环形缓冲区。
6. 设置socket状态为TCP_CLOSED。

tcp_sock_lookup_established

这个函数从从established_table中查询符合要求的socket，并返回。

查询过程如下：

1. 用四元组(saddr, daddr, sport, dport)计算hash。
2. 遍历相应的队列，将socket取出，并返回。
3. 若没有找到，则返回NULL。

tcp_sock_lookup_listen

这个函数跟tcp_sock_lookup_established作用类似，是在listen_table中查询。计算hash时，只使用sport，其他位置用0代替。

tcp_sock_connect

这个函数是客户端用来发起连接的函数。需要：

1. 设置源地址、目的地址、源端口、目的端口。
2. 将socket加入到bind_table中。
3. 将socket置为TCP_SYN_SENT状态，并加入到established_table中。
4. 发送SYN报文。
5. 阻塞在wait_connect，等待被唤醒。

PS：一定要注意2和3的顺序，如果先发送SYN报文，在网速快并且CPU特别慢的时候，会出现收到SYN|ACK报文时，socket还没有插入到established_table中，这就会造成在tcp_sock_lookup_established函数中找不到相应的socket，造成程序错误。

tcp_sock_listen

这个函数使socket进入TCP_LISTEN状态，并插入到listen_table中。

tcp_sock_accept

ServerSocket使用这个函数，获取一个新建立的连接，进行处理。

1. 若ServerSocket的accept_queue不为空，则直接弹出队列的第一个元素，并返回。
2. 若accept_queue为空，则等待wait_accept。被唤醒后，弹出队列的第一个元素，并返回。

tcp_sock_read

使用该函数接收socket发送过来的数据。

1. 若环形缓冲区为空，则等待wait_recv，唤醒后读取数据、调整窗口并返回。
2. 若环形缓冲区不为空，则直接调整窗口并返回数据。

tcp_sock_write

使用该函数发送数据。直接调用tcp_send_data函数发送数据。
PS：获取需要验证窗口大小。

实验收获

• 通过这次实验，真正清晰的了解了TCP连接建立与断开的详细过程。
• 通过阅读老师给的代码，学习到了一种新的链表结构，与之前学习的链表有很大的不同，非常高效且不浪费空间。
• 通过阅读代码，并查阅资料，了解了如何禁用系统的协议栈，实现用户态的TCP/IP栈。

虽然之前也写过编译OpenWRT的文章，但是由于版本等原因，此次遇到的问题与之前不太一样，特地记录一下。

编译环境

• Archlinux 64bit
• GCC v7.2.0
• Perl v5.26.1

项目源码

项目源码托管在GitHub上，地址如下：**openwrt**。

前提工作

1. 必装工具
   可以在这里找到目前支持系统的编译工具。

   Archlinux的安装命令如下：

   1	sudo pacman -S --needed subversion asciidoc bash bc binutils bzip2 fastjar flex git gcc util-linux gawk intltool zlib mercurial make cdrkit ncurses openssl patch perl-extutils-makemaker rsync sdcc unzip wget gettext libxslt boost libusb bin86 sharutils b43-fwcutter findutils

2. Checkout项目代码

   1	git clone git@github.com:openwrt/openwrt.git

取得源代码后，需要执行下面的命令，将package全部安装。

1
2

./scripts/feeds update -a
./scripts/feeds install -a

编译

1
2
3

cd openwrt
make menuconfig
make V=s -j1

遇到的问题

出现问题的部分主要是host工具编译出错。主要是因为这些工具之间有相互依赖，某个部分修改后，会引起不兼容的问题。

automake编译报错

Perl版本过高会导致Perl脚本的正则匹配出现问题，在Perl 5中取消了正则匹配的大括号（{、}），因此，只需要在相应的文件中，把大括号删掉就行了。

注意：编译报错是由一个tmp文件引起的，因此，需要修改生成tmp文件的源文件，才可以修复错误。

u-boot编译报错

这个错误是由于rsa库版本更新导致的，需要使用这个**补丁文件**进行修复。

修复时，需要将不定文件放在与rsa-sign.c相同目录下执行。

cmake编译错误

这个问题是由于openssl版本引起的，可以使用系统自带的openssl回避这个问题。

在cmake根目录下，手动编译安装，在配置时，需要指明使用系统的库文件。记得修改PATH

1
2
3

./configure --system-libs --prefix=<PATH>/openwrt/staging_dir/host
make
make install

cmake编译错误

这个问题是由于系统缺少JsonCpp库引起的，在系统中安装一下就行了。

• JAVA_HOME = C:\Program Files\Java\jdk-9.0.1

• CLASSPATH = .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar

• Path += %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

PS:最新的Windows 10中的环境变量，需要在设置中搜索编辑系统环境变量打开。

获取repo

访问：https://dev.mysql.com/downloads/repo/yum/
下载rpm文件

安装

1
2

sudo rpm -ivh mysql57-community*.rpm
yum install -y mysql-server

运行

1

sudo systemctl start mysqld

重置密码

MySQL 5.7以上，会在安装时会默认生成一个临时密码。MySQL 5.6以下则默认密码为空。

1
2

# 获取临时密码
sudo grep 'temporary password' /var/log/mysqld.log

显示如下信息：

1

2016-12-01T00:22:31.416107Z 1 [Note] A temporary password is generated for root@localhost: mqRfBU_3Xk>r

重置密码：

1

sudo mysql_secure_installation

输入临时密码，然后再输入新密码就可以了。

新密码要求是强密码，需要包含字母、数字、特殊符号。

允许远程访问

授权用户远程访问

1

grant all privileges  on *.* to user@'ip' identified by "password";

如果允许任意地址，则将@'ip'换成@'%'。

今天看netfilter的源码，发现一个打印点分十进制的好方法：使用NIPQUAD和NIPQUAD_FMT宏：

1
2
3
4
5
6
7

#define NIPQUAD_FMT "%u.%u.%u.%u"

#define NIPQUAD(addr) \
 ((unsigned char *)&addr)[0], \
 ((unsigned char *)&addr)[1], \
 ((unsigned char *)&addr)[2], \
 ((unsigned char *)&addr)[3]

写个测试代码:

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

#include <stdio.h>

#define NIPQUAD_FMT "%u.%u.%u.%u"

#define NIPQUAD(addr) \
 ((unsigned char *)&addr)[0], \
 ((unsigned char *)&addr)[1], \
 ((unsigned char *)&addr)[2], \
 ((unsigned char *)&addr)[3]


int main() {
    unsigned int ip;
    ip = htonl(3232235777);
    printf("ip = " NIPQUAD_FMT "\n", NIPQUAD(ip));
}

输出结果:

1
2

tony@ubuntu-a:~/code$ ./a.out 
ip = 192.168.1.1

这个用法要注意的就是，NIPQUAD的参数需要是网络序的，所以事先用htonl转一下就可以了。

核心态

另外还看到一种用法，就是使用%pI4打印地址：

1

sprintf(buffer, "%pI4", &ip);

网上是这样说的：

The kernel’s family of printf() functions has a special format specifier for IP-addresses (%pI4 for IPv4-addresses, %pI6 for IPv6).

也就是说这种格式仅供内核来使用，一般用户程序是不能用的。

• Ubuntu 12.04 32bit
• Windows Subsystem for Linux

项目源码

项目源码托管在GitHub上，地址如下：**openwrt-hc5x61**。

本项目不是官方支持的OpenWRT，因此OpenWRT版本比较旧，有较大的差别。

本项目使用的是极路由的极路由2路由器。

前提工作

1. 必装工具(仅限Debian和Ubuntu)

   1	sudo apt-get install build-essential git subversion wget flex gettext libncurses5-dev unzip gawk liblzma-dev zlib1g-dev ccache u-boot-tools

2. Checkout项目代码

   1	git clone https://github.com/rssnsj/openwrt-hc5x61.git

   编译

   注意：建议国内用户在编译过程中全程翻墙，因为会从国外下载一些额外的软件包。推荐使用proxychains，具体使用方法，请自行Google

   1 2 3 4 5 6 7

   cd openwrt-hc5x61 # 将hc5761(极2)设置为编译目标对象 ln -s ./config-hiwifi-hc5761 ./config-hiwifi # 可自定义自己需要的额外功能 make menuconfig # 编译 make

   编译成功后，目标文件在openwrt-ramips/bin/ramips/openwrt-ramips-mt7620a-hc5761-squashfs-sysupgrade.bin

注意1：
编译过程中，会有一些组件下载失败，手动下载同名的文件放到openwrt-ramips/dl下面，再执行make继续编译。
注意2：
pdnsd组件原项目地址已经失效，请单独下载，注意切换分支。
文件名为：pdnsd-1.2.9a-par-a8e46ccba7b0fa2230d6c42ab6dcd92926f6c21d.tar.gz
commit Hash:a8e46ccba7b0fa2230d6c42ab6dcd92926f6c21d

刷机

FTP

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

# 登录路由器(IP地址是路由器地址)
ssh root@192.168.199.1
cd /tmp

# 替换U-boot以防止万一刷砖无法直接tftp刷root固件
# 已经替换的可以忽略，以极2为例，其他请参考项目文档
wget http://rssn.cn/roms/uboot/HC5761-uboot.bin
mtd write HC5761-uboot.bin u-boot

# 下载固件
# 可以通过FTP等方式，将刚刚生成的文件放到/tmp文件夹下

# 刷机
sysupgrade -F -n openwrt-ramips-mt7620a-hc5761-squashfs-sysupgrade.bin

Selector的主要方法有三个：

• Selector.open():Selector
  主要用于创建一个selector
• select():int
  该方法有两种模式：在阻塞模式下，该方法会一直阻塞，直到超时或者有注册的事件发生，返回发生事件的数量；在非阻塞模式下，会立即返回，如果没有事件发生，则返回0。
• selectedKeys():Set
  获取已经就绪的事件的key的集合。

Selector.open()原理

通过阅读java.nio.channels.Selector的源码（如下），可以发现，其调用了SelectorProvider.provider()的openSelector()函数。

1
2
3

public static Selector More ...open() throws IOException {
    return SelectorProvider.provider().openSelector();
}

先看SelectorProvider.provider()，在这个函数中，保证了provider有且仅有一个。

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

public static SelectorProvider provider() {
    synchronized (lock) {
        if (provider != null)   //保证只有一个
            return provider;
        return AccessController.doPrivileged(
            new PrivilegedAction<SelectorProvider>() {
                public SelectorProvider run() {
                    if (loadProviderFromProperty())
                        return provider;
                    if (loadProviderAsService())
                        return provider;
                    provider = sun.nio.ch.DefaultSelectorProvider.create();
                    return provider;
                }
            });
    }
}

再看create()函数，在该函数中，区分了操作系统，在Windows下，使用的是sun.nio.ch.PollSelectorProvider类，作为Selector。也就是说，SelectorProvider.provider()返回了一个PollSelectorProvider对象。

1
2
3
4
5
6
7
8
9

public static SelectorProvider create() {
    String osname = AccessController
        .doPrivileged(new GetPropertyAction("os.name"));
    if (osname.equals("SunOS"))
        return createProvider("sun.nio.ch.DevPollSelectorProvider");
    if (osname.equals("Linux"))
        return createProvider("sun.nio.ch.EPollSelectorProvider");
    return new sun.nio.ch.PollSelectorProvider();
}

在sun.nio.ch.PollSelectorProvider的openSelector()函数（如下）中，返回了一个PollSelectorImpl的对象。

1
2
3
4
5
6
7
8
9
10
11

public class PollSelectorProvider
    extends SelectorProviderImpl
{
    public AbstractSelector openSelector() throws IOException {
        return new PollSelectorImpl(this);
    }

    public Channel inheritedChannel() throws IOException {
        return InheritedChannel.getChannel();
    }
}

在PollSelectorImpl的构造器（如下）中，我发现，其创建了一个pipe，创建函数是IOUtil.makePipe()，但是这个函数是native的，我估计应该是OS提供的一个函数。这个pipe的主要作用是，在select()函数被阻塞的时候，用于唤醒线程使用。

需要注意的是，虽然函数名称叫做makePipe，但是在Windows平台下实现中，并没有使用pipe，而是使用的TCP连接。

同时还要注意super函数的参数，第一个1是channels总数，第二个1是偏移量，说明，在初始化过程中，就已经有一个channel在这个数组中了，channels[0]就是刚刚创建的pipe。这个channel就是用来唤醒select()的。

1
2
3
4
5
6
7
8
9

PollSelectorImpl(SelectorProvider sp) {
    super(sp, 1, 1);
    long pipeFds = IOUtil.makePipe(false);  //创建pipe
    fd0 = (int) (pipeFds >>> 32);
    fd1 = (int) pipeFds;
    pollWrapper = new PollArrayWrapper(INIT_CAP);
    pollWrapper.initInterrupt(fd0, fd1);
    channelArray = new SelectionKeyImpl[INIT_CAP];
}

综上所述，Selector.open()函数的作用是：保证了provider有且仅有一个，并返回了一个PollSelectorImpl对象，同时创建了一条pipe。

select()原理

select的执行体是在sun.nio.ch.PollSelectorImpl中的doSelect函数（如下）。

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

protected int doSelect(long timeout)
    throws IOException
{
    if (channelArray == null)
        throw new ClosedSelectorException();
    processDeregisterQueue();
    try {
        begin();
        pollWrapper.poll(totalChannels, 0, timeout);    //在这里轮询
    } finally {
        end();
    }
    processDeregisterQueue();
    int numKeysUpdated = updateSelectedKeys();
    if (pollWrapper.getReventOps(0) != 0) {
        // Clear the wakeup pipe
        pollWrapper.putReventOps(0, 0);
        synchronized (interruptLock) {
            IOUtil.drain(fd0);
            interruptTriggered = false;
        }
    }
    return numKeysUpdated;
}

updateSelectedKeys()函数（如下）的实现是在sun.nio.ch.AbstractPollSelectorImpl中。
通过getReventOps()函数来判断通道是否有事件发生，若发生，将其加入到selectedKeys中。

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

/**
 * Copy the information in the pollfd structs into the opss
 * of the corresponding Channels. Add the ready keys to the
 * ready queue.
 */
protected int updateSelectedKeys() {
    int numKeysUpdated = 0;
    // Skip zeroth entry; it is for interrupts only
    // 第0个是自带的，用于唤醒select()的，因此从1开始循环。
    for (int i=channelOffset; i<totalChannels; i++) {
        int rOps = pollWrapper.getReventOps(i);
        if (rOps != 0) {
            SelectionKeyImpl sk = channelArray[i];
            pollWrapper.putReventOps(i, 0);
            if (selectedKeys.contains(sk)) {
                if (sk.channel.translateAndSetReadyOps(rOps, sk)) {
                    numKeysUpdated++;
                }
            } else {
                sk.channel.translateAndSetReadyOps(rOps, sk);
                if ((sk.nioReadyOps() & sk.nioInterestOps()) != 0) {
                    selectedKeys.add(sk);
                    numKeysUpdated++;
                }
            }
        }
    }
    return numKeysUpdated;
}

selectedKeys()原理

该方法直接返回publicSelectedKeys这个Set。

1
2
3
4
5

public Set<SelectionKey> selectedKeys() {
    if (!isOpen() && !Util.atBugLevel("1.4"))
        throw new ClosedSelectorException();
    return publicSelectedKeys;
}

publicSelectedKeys在SelectorImpl中的初始化中，与selectedKeys做了绑定，并在updateSelectedKeys()函数中，进行更新。

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

protected SelectorImpl(SelectorProvider sp) {
    super(sp);
    keys = new HashSet<SelectionKey>();
    selectedKeys = new HashSet<SelectionKey>();
    if (Util.atBugLevel("1.4")) {
        publicKeys = keys;
        publicSelectedKeys = selectedKeys;
    } else {
        publicKeys = Collections.unmodifiableSet(keys);
        publicSelectedKeys = Util.ungrowableSet(selectedKeys);
    }
}

参考文献

1. Java NIO
2. Java NIO 系列教程
3. Java源码

• capacity
  作为一个内存块，Buffer有一个固定的大小值，也叫capacity.你只能往里写capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空(通过读数据或者清除数据)才能继续写数据往里写数据。

• position
  当你写数据到Buffer中时，position表示当前的位置。初始的position值为0。position最大可为capacity–1。当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

• limit
  在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。写模式下，limit等于Buffer的capacity。当切换Buffer到读模式时，limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据。

• 三者关系如下：

Buffer构造器

尽管Buffer是一个抽象类，但是依然有自己的构造器。
其主要作用是初始化抽象类的成员和子类的初始化。

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

Buffer(int mark, int pos, int lim, int cap) {       // package-private
    if (cap < 0)
        throw new IllegalArgumentException("Negative capacity: " + cap);
    this.capacity = cap;
    limit(lim);
    position(pos);
    if (mark >= 0) {
        if (mark > pos)
            throw new IllegalArgumentException("mark > position: ("
                                               + mark + " > " + pos + ")");
        this.mark = mark;
    }
}

Buffer常用方法

• allocate() 分配一段空间的Buffer对象
• put() 用于往Buffer中添加元素
• flip() 用于将写模式转化为读模式
• hasRemaining() 判断Buffer中是否还有元素可读
• get() 读取Buffer中position位置的元素
• clear() 清空Buffer
• compact() 清除已读取的部分

关于Buffer的数据结构

通过查看java.nio.IntBuffer这个类的初始化函数及成员（如下），可以确定，Buffer的基本数据结构是数组！

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

final int[] hb;                  // Non-null only for heap buffers
final int offset;
boolean isReadOnly;                 // Valid only for heap buffers

// Creates a new buffer with the given mark, position, limit, capacity,
// backing array, and array offset
//
IntBuffer(int mark, int pos, int lim, int cap,   // package-private
          int[] hb, int offset)
{
    super(mark, pos, lim, cap);
    this.hb = hb;
    this.offset = offset;
}

关于compact函数的实现

这个函数我是比较感兴趣的，他与clear()的区别是只删除已读的部分。

通过查看java.nio.HeapIntBuffer，该类是java.nio.IntBuffer的子类，可以得知compact函数的实现。

1
2
3
4
5
6
7
8
9
10
11

public IntBuffer compact() {
    // 将剩余的没有访问的元素拷贝到Buffer从零开始的位置
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    // 重置position
    position(remaining());
    // 重置limit
    limit(capacity());
    // 删除mark
    discardMark();
    return this;
}

参考文献

1. Java NIO
2. Java NIO 系列教程
3. Java源码