count= n= rem=    这表示划分了4个数据块，数据块大小为3字节，剩余1字节给了最后一个数据块

chunk[]：offset= len= 该数据块对应的内容为123

chunk[]：offset= len= 该数据块对应的内容为abc

chunk[]：offset= len= 该数据块对应的内容为def

chunk[]：offset= len= 该数据块对应的内容为g

chunk[] sum1=3ef2c827 sum2=3efa923f8f2e7

chunk[] sum1=57ac2aaf sum2=aef2dedba2314

chunk[] sum1=92d7edb4 sum2=a6sd6a9d67a12

chunk[] sum1=afe74939 sum2=90a12dfe7485c

chunk[] of size  at  offset=

data receive  at

chunk[] of size  at  offset=

data receive  at

chunk[] of size  at  offset=

[root@xuexi ~]# rsync -a -vvvv /etc/cron.d /var/log/anaconda /etc/issue longshuai@172.16.10.5:/tmp

# 使用ssh(ssh为默认的远程shell)执行远程rsync命令建立连接

cmd=<NULL> machine=172.16.10.5 user=longshuai path=/tmp

cmd[]=ssh cmd[]=-l cmd[]=longshuai cmd[]=172.16.10.5 cmd[]=rsync cmd[]=--server cmd[]=-vvvvlogDtpre.iLsf cmd[]=. cmd[]=/tmp

opening connection using: ssh -l longshuai 172.16.10.5 rsync --server -vvvvlogDtpre.iLsf . /tmp

note: iconv_open("UTF-8", "UTF-8") succeeded.

longshuai@172.16.10.5's password:

# 双方互相发送协议版本号，并协商使用两者较低版本

(Server) Protocol versions: remote=, negotiated=

(Client) Protocol versions: remote=, negotiated=

######### sender端生成文件列表并发送给receiver端 #############

sending incremental file list

[sender] make_file(cron.d,*,)       # 第一个要传输的文件目录：cron.d文件，注意，此处cron.d是待传输的文件，而不认为是目录

[sender] make_file(anaconda,*,)     # 第二个要传输的文件目录：anaconda文件

[sender] make_file(issue,*,)        # 第三个要传输的文件目录：issue文件

# 指明从文件列表的第1项开始，并确定这次要传输给receiver的项共有3个

[sender] flist start=, used=, low=, high=

# 为这3项生成列表信息，包括此文件id，所在目录，权限模式，长度，uid/gid，最后还有一个修饰符

[sender] i= /etc issue mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/ mode= len= uid= gid= flas=

[sender] i= /etc cron.d/ mode= len= uid= gid= flags=

send_file_list done

file list sent

# 唯一需要注意的是文件所在目录，例如/var/log anaconda/，但实际在命令行中指定的是/var/log/anaconda。

# 此处信息中log和anaconda使用空格分开了，这个空格非常关键。空格左边的表示隐含目录(见man rsync的"-R"选项)，

# 右边的是待传输的整个文件或目录，默认情况下将会在receiver端生成anaconda/目录，但左边隐含目录则不会创建。

# 但可以通过指定特殊选项(如"-R")，让rsync也能在receiver端同时创建隐含目录，以便创建整个目录层次结构。

# 举个例子，如果A主机的/a目录下有b、c等众多子目录，并且b目录中有d文件，现在只想传输/a/b/d并保留/a/b的目录层次结构，

# 那么可以通过特殊选项让此处的文件所在目录变为"/ a/"，关于具体的实现方法，见"rsync -R选项示例"。

############ sender端发送文件属性信息 #####################

# 由于前面的文件列表中有两个条目是目录，因此还要为目录中的每个文件生成属性信息并发送给receiver端

send_files starting

[sender] make_file(anaconda/anaconda.log,*,)

[sender] make_file(anaconda/syslog,*,)

[sender] make_file(anaconda/program.log,*,)

[sender] make_file(anaconda/packaging.log,*,)

[sender] make_file(anaconda/storage.log,*,)

[sender] make_file(anaconda/ifcfg.log,*,)

[sender] make_file(anaconda/ks-script-1uLekR.log,*,)

[sender] make_file(anaconda/ks-script-iGpl4q.log,*,)

[sender] make_file(anaconda/journal.log,*,)

[sender] flist start=, used=, low=, high=

[sender] i= /var/log anaconda/anaconda.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/ifcfg.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/journal.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/ks-script-1uLekR.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/ks-script-iGpl4q.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/packaging.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/program.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/storage.log mode= len= uid= gid= flags=

[sender] i= /var/log anaconda/syslog mode= len= uid= gid= flags=

[sender] make_file(cron.d/0hourly,*,)

[sender] make_file(cron.d/sysstat,*,)

[sender] make_file(cron.d/raid-check,*,)

[sender] flist start=, used=, low=, high=

[sender] i= /etc cron.d/0hourly mode= len= uid= gid= flags=

[sender] i= /etc cron.d/raid-check mode= len= uid= gid= flags=

[sender] i= /etc cron.d/sysstat mode= len= uid= gid= flags=

# 从上述结果中发现，没有i=4和i=14的文件信息，因为它们是目录anaconda和cron.d的文件信息

# 还发现没有发送/etc/issue文件的信息，因为issue自身是普通文件而非目录，因此在发送目录前就发送了

############# 文件列表所有内容发送完毕 ####################

############### server端相关活动内容 ################

# 首先在server端启动rsync进程

server_recv() starting pid=

# 接收client第一次传输的数据，此次传输server端收到3条数据，它们是传输中根目录下的文件或目录

received  names

[receiver] flist start=, used=, low=, high=

[receiver] i=  issue mode= len= gid=() flags=

[receiver] i=  anaconda/ mode= len= gid=() flags=

[receiver] i=  cron.d/ mode= len= gid=() flags=

recv_file_list done

# 第一次接收数据完成

############ 在receiver端启动generator进程 ########

get_local_name count= /tmp   # 获取本地路径名

generator starting pid=  # 启动generator进程

delta-transmission enabled    # 启用增量传输算法

############ generator进程设置完毕 ################

############# 首先处理接收到的普通文件 ##############

recv_generator(issue,)       # generator收到receiver进程通知的文件id=1的文件issue

send_files(, /etc/issue)

count= n= rem=             # 此项为目标主机上的文件issue分割的数据块信息，count表示数量，n表示数据块的固定大小，

                              # rem是remain的意思，表示剩余的数据长度，也即最后一个数据块的大小，

                              # 此处因为目标端不存在issue文件，因此全部设置为0

send_files mapped /etc/issue of size   # sender端映射/etc/issue，使得sender可以获取到该文件的相关内容

calling match_sums /etc/issue            # sender端调用校验码匹配功能

issue

sending file_sum                         # 匹配结束后，再发送文件级的checksum给receiver端

false_alarms= hash_hits= matches=     # 输出数据块匹配的相关统计信息

sender finished /etc/issue

# 文件/etc/issue发送完毕，因为目标上不存在issue文件，所以整个过程非常简单，直接传输issue中的全部数据即可

############## 开始处理目录格式的文件列表 #############

# 首先接收到两个id=2和id=3的文件

recv_generator(anaconda,)

recv_generator(cron.d,)

# 然后开始从文件列表的目录中获取其中的文件信息

recv_files() starting

# 先获取的是dir 0的目录中的文件信息

[receiver] receiving flist for dir

[generator] receiving flist for dir

received  names                                    # 表示从该目录中收到了9条文件信息

[generator] flist start=, used=, low=, high=    # 文件的id号从5开始，总共有9个条目

[generator] i=  anaconda/anaconda.log mode= len= gid=() flags=

[generator] i=  anaconda/ifcfg.log mode= len= gid=() flags=

[generator] i=  anaconda/journal.log mode= len= gid=() flags=

[generator] i=  anaconda/ks-script-1uLekR.log mode= len= gid=() flags=

[generator] i=  anaconda/ks-script-iGpl4q.log mode= len= gid=() flags=

[generator] i=  anaconda/packaging.log mode= len= gid=() flags=

[generator] i=  anaconda/program.log mode= len= gid=() flags=

[generator] i=  anaconda/storage.log mode= len= gid=() flags=

[generator] i=  anaconda/syslog mode= len= gid=() flags=

recv_file_list done                                 # dir 0目录中的文件信息接收完毕

[receiver] receiving flist for dir                 # 然后获取的是dir 1的目录中的文件信息

[generator] receiving flist for dir

received  names

[generator] flist start=, used=, low=, high=

[generator] i=  cron.d/0hourly mode= len= gid=() flags=

[generator] i=  cron.d/raid-check mode= len= gid=() flags=

[generator] i=  cron.d/sysstat mode= len= gid=() flags=

recv_file_list done                                 # dir 1目录中的文件信息接收完毕

################# 开始传输目录dir 0及其内文件 #############

recv_generator(anaconda,)             # generator接收目录anaconda信息，它的id=，是否还记得上文sender未发送过id=4和

                                       # id=14的目录信息？只有先接收该目录，才能继续接收该目录中的文件

send_files(, /var/log/anaconda)       # 因为anaconda是要在receiver端创建的目录，所以sender端先发送该目录文件

anaconda/                              # anaconda目录发送成功

set modtime of anaconda to () Thu May  ::    # 然后再设置目录anaconda的mtime(即modify time)

# receiver端的anaconda目录已经建立，现在开始传输anaconda中的文件

# 以下的第一个anaconda目录中的第一个文件处理过程

recv_generator(anaconda/anaconda.log,)          # generator进程接收id=5的anaconda/anaconda.log文件

send_files(, /var/log/anaconda/anaconda.log)

count= n= rem=                                # 计算该文件数据块相关信息

send_files mapped /var/log/anaconda/anaconda.log of size     # sender端映射anaconda.log文件

calling match_sums /var/log/anaconda/anaconda.log                # 调用校验码匹配功能

anaconda/anaconda.log

sending file_sum                                 # 数据块匹配结束后，再发送文件级别的checksum给receiver端

false_alarms= hash_hits= matches=             # 输出匹配过程中的统计信息

sender finished /var/log/anaconda/anaconda.log   # anaconda.log文件传输完成

recv_generator(anaconda/ifcfg.log,)             # 开始处理anaconda中的第二个文件

send_files(, /var/log/anaconda/ifcfg.log)

count= n= rem=

send_files mapped /var/log/anaconda/ifcfg.log of size

calling match_sums /var/log/anaconda/ifcfg.log

anaconda/ifcfg.log

sending file_sum

false_alarms= hash_hits= matches=

sender finished /var/log/anaconda/ifcfg.log      # 第二个文件传输完毕

recv_generator(anaconda/journal.log,)           # 开始处理anaconda中的第三个文件

send_files(, /var/log/anaconda/journal.log)

count= n= rem=

send_files mapped /var/log/anaconda/journal.log of size

calling match_sums /var/log/anaconda/journal.log

anaconda/journal.log

sending file_sum

false_alarms= hash_hits= matches=

sender finished /var/log/anaconda/journal.log    # 第二个文件传输完毕

#以下类似过程省略

......

recv_generator(anaconda/syslog,)               # 开始处理anaconda中的最后一个文件

send_files(, /var/log/anaconda/syslog)

count= n= rem=

send_files mapped /var/log/anaconda/syslog of size

calling match_sums /var/log/anaconda/syslog

anaconda/syslog

sending file_sum

false_alarms= hash_hits= matches=

sender finished /var/log/anaconda/syslog        # anaconda目录中所有文件传输完毕

################# 开始传输目录dir 1及其内文件 #############

recv_generator(cron.d,)

send_files(, /etc/cron.d)

cron.d/

set modtime of cron.d to () Thu May  ::

recv_generator(cron.d/0hourly,)

send_files(, /etc/cron.d/0hourly)

count= n= rem=

send_files mapped /etc/cron.d/0hourly of size

calling match_sums /etc/cron.d/0hourly

cron.d/0hourly

sending file_sum

false_alarms= hash_hits= matches=

sender finished /etc/cron.d/0hourly

......类似过程省略......

recv_generator(cron.d/sysstat,)

send_files(, /etc/cron.d/sysstat)

count= n= rem=

send_files mapped /etc/cron.d/sysstat of size

calling match_sums /etc/cron.d/sysstat

cron.d/sysstat

sending file_sum

false_alarms= hash_hits= matches=

sender finished /etc/cron.d/sysstat

############## 以下是receiver端文件重组相关过程 ################

generate_files phase=     # generator进程进入第一阶段

# 重组第一个文件issue

recv_files(issue)

data recv  at    # data recv关键字表示从sender端获取的纯文件数据，23表示接收到的这一段纯数据大小为23字节，

                    # at 0表示接收的这段数据放在临时文件的起始偏移0处。

got file_sum        # 获取到sender端最后发送的文件级的checksum，并进行检查，检查通过则表示重组正式完成

set modtime of .issue.RpT9T9 to () Wed Dec   ::   # 临时文件重组完成后，设置临时文件的mtime

renaming .issue.RpT9T9 to issue        # 最后将临时文件重命名为目标文件

# 至此，第一个文件真正完成同步

# 重组第二个文件列表anaconda及其内文件

recv_files(anaconda)  # 重组目录anaconda

recv_files(anaconda/anaconda.log)   # 重组目录anaconda中的第一个文件

data recv  at

got file_sum

set modtime of anaconda/.anaconda.log.LAR2t1 to () Thu May  ::

renaming anaconda/.anaconda.log.LAR2t1 to anaconda/anaconda.log     # anaconda目录中的第一个文件同步完成

recv_files(anaconda/ifcfg.log)               # 重组目录anaconda中的第二个文件

data recv  at

got file_sum

set modtime of anaconda/.ifcfg.log.bZDW3S to () Thu May  ::

renaming anaconda/.ifcfg.log.bZDW3S to anaconda/ifcfg.log     # anaconda目录中的第二个文件同步完成

recv_files(anaconda/journal.log)     # 重组目录anaconda中的第三个文件

data recv  at                  # 由于每次传输的数据量最大为32kB，因此对于较大的journal.log分成了多次进行传输

data recv  at

data recv  at

..............

got file_sum

set modtime of anaconda/.journal.log.ylpZDK to () Thu May  ::

renaming anaconda/.journal.log.ylpZDK to anaconda/journal.log       # anaconda目录中的第三个文件同步完成

.........中间类似过程省略...........

recv_files(anaconda/syslog)

data recv  at

data recv  at

data recv  at

................

got file_sum

set modtime of anaconda/.syslog.zwQynW to () Thu May  ::

renaming anaconda/.syslog.zwQynW to anaconda/syslog

# 至此，anaconda及其内所有文件都同步完毕

# 重组第三个文件列表cron.d及其内文件

recv_files(cron.d)

recv_files(cron.d/0hourly)

......中间类似过程省略..........

recv_files(cron.d/sysstat)

data recv  at

got file_sum

set modtime of cron.d/.sysstat.m4hzgx to () Fri Mar   ::

renaming cron.d/.sysstat.m4hzgx to cron.d/sysstat

# 至此，cron.d及其内所有文件都同步完毕

send_files phase=

touch_up_dirs: cron.d ()  # sender进程修改上层目录cron.d的各种时间戳

set modtime of cron.d to () Thu May  ::    # 设置cron.d目录的mtime

recv_files phase=

generate_files phase=

send_files phase=

send files finished        # sender进程消逝，并输出匹配的统计信息以及传输的总的纯数据量

total: matches=  hash_hits=  false_alarms= data=

recv_files phase=

generate_files phase=

recv_files finished

generate_files finished

client_run waiting on  

sent  bytes  received  bytes  242969.38 bytes/sec    # 总共发送了1579034字节的数据，此项统计包括了纯文件数据以

                                                               # 及各种非文件数据，接收到了来自receiver端的267字节的数据

total size is   speedup is 1.00     # sender端所有文件总大小为1577975字节，因为receiver端完全没有basis file，

                                           # 所以总大小等于传输的纯数据量

[sender] _exit_cleanup(code=, file=main.c, line=): entered

[sender] _exit_cleanup(code=, file=main.c, line=): about to call exit()

[root@xuexi ~]# rsync -vvvv /tmp/init 172.16.10.5:/tmp

# 使用ssh(ssh为默认的远程shell)执行远程rsync命令建立连接

cmd=<NULL> machine=172.16.10.5 user=<NULL> path=/tmp

cmd[]=ssh cmd[]=172.16.10.5 cmd[]=rsync cmd[]=--server cmd[]=-vvvve.Lsf cmd[]=. cmd[]=/tmp

opening connection using: ssh 172.16.10.5 rsync --server -vvvve.Lsf . /tmp

note: iconv_open("UTF-8", "UTF-8") succeeded.

root@172.16.10.5's password:

# 双方互相发送协议版本号，并协商使用两者较低版本

(Server) Protocol versions: remote=, negotiated=

(Client) Protocol versions: remote=, negotiated=

[sender] make_file(init,*,)

[sender] flist start=, used=, low=, high=

[sender] i= /tmp init mode= len= flags=

send_file_list done

file list sent                       

send_files starting

server_recv() starting pid=    # 在远程启动receiver进程

received  names

[receiver] flist start=, used=, low=, high=

[receiver] i=  init mode= len= flags=

recv_file_list done

get_local_name count= /tmp

generator starting pid=         # 在远程启动generator进程

delta-transmission enabled

recv_generator(init,)

recv_files() starting

gen mapped init of size          # generator进程映射basis file文件(即本地的init文件)，只有映射后各进程才能获取该文件相关数据块

generating and sending sums for     # 生成init文件的弱滚动校验码和强校验码集合，并发送给sender端

send_files(, /tmp/init)             # 以下generator生成的校验码集合信息

count= rem= blength= s2length= flength=

count= n= rem=                # count=8表示该文件总共计算了8个数据块的校验码，n=700表示固定数据块的大小为700字节，

                                     # rem=(remain)表示最终剩240字节，即最后一个数据块的长度

chunk[] offset= len= sum1=3ef2e827

chunk[] len= offset= sum1=3ef2e827

chunk[] offset= len= sum1=57aceaaf

chunk[] len= offset= sum1=57aceaaf

chunk[] offset= len= sum1=92d7edb4

chunk[] len= offset= sum1=92d7edb4

chunk[] offset= len= sum1=afe7e939

chunk[] len= offset= sum1=afe7e939

chunk[] offset= len= sum1=fcd0e7d5

chunk[] len= offset= sum1=fcd0e7d5

chunk[] offset= len= sum1=0eaee949

chunk[] len= offset= sum1=0eaee949

chunk[] offset= len= sum1=ff18e40f

chunk[] len= offset= sum1=ff18e40f

chunk[] offset= len= sum1=858d519d

chunk[] len= offset= sum1=858d519d

# sender收到校验码集合后，准备开始数据块匹配过程

send_files mapped /tmp/init of size  # sender进程映射本地的/tmp/init文件，只有映射后各进程才能获取该文件相关数据块

calling match_sums /tmp/init             # 开始调用校验码匹配功能，对/tmp/init文件进行搜索匹配

init

built hash table                         # sender端根据接收到的校验码集合中的滚动校验码生成16位长度的hash值，并将hash值放入hash表

hash search b= len=               # 第一层hash搜索，搜索的数据块大小为700字节，总搜索长度为8640，即整个/tmp/init的大小

sum=3ef2e827 k=

hash search s->blength= len= count=

potential match at  i= sum=3ef2e827           # 在chunk[]上发现潜在的匹配块，其中i表示的是sender端匹配块的编号

match at  last_match= j= len= n=         # 最终确定起始偏移0上的数据块能完全匹配上，j表示的是校验码集合中的chunk编号。

                                                # 此过程中可能还进行了rolling checksum以及强校验码的匹配

potential match at  i= sum=57aceaaf

match at  last_match= j= len= n=     # last_match的值是上一次匹配块的终止偏移

potential match at  i= sum=92d7edb4

match at  last_match= j= len= n=

potential match at  i= sum=afe7e939

match at  last_match= j= len= n=

potential match at  i= sum=ff18e40f         # 在chunk[]上发现潜在的匹配块，

match at  last_match= j= len= n= # 此次匹配块的起始偏移地址是7509，而上一次匹配块的结尾偏移是2800，

                                                 # 中间4709字节的数据都是未匹配上的，这些数据需要以纯数据的方式发送给receiver端

done hash search      # 匹配结束

sending file_sum      # sender端匹配结束后，再生成文件级别的checksum，并发送给receiver端

false_alarms= hash_hits= matches=    # 输出此次匹配过程中的统计信息，总共有5个匹配块，全都是hash匹配出来的，

                                        # 没有进行第二层次的rolling checksum检查

sender finished /tmp/init     # sender端完成搜索和匹配过程

send_files phase=            # sender进程进入第一阶段

# sender进程暂时告一段落

# 进入receiver端进行操作

generate_files phase=        # generator进程进入第一阶段

recv_files(init)              # receiver进程读取本地init文件

recv mapped init of size                 # receiver进程映射init文件，即basis file

##################### 以下是文件重组过程 #####################

chunk[] of size  at  offset=           # receiver进程从basis file中拷贝chunk[]对应的数据块到临时文件中

chunk[] of size  at  offset=       # receiver进程从basis file中拷贝chunk[]对应的数据块到临时文件中

chunk[] of size  at  offset=

chunk[] of size  at  offset=

data recv  at                        # receiver进程从2800偏移处开始接收sender发送的纯数据到临时文件中，共4709字节

chunk[] of size  at  offset=     # receiver进程从basis file起始偏移4200处拷贝chunk[]对应的数据块到临时文件中

data recv  at                         # receiver进程从8209偏移处开始接收sender发送的纯数据到临时文件中，共431字节

got file_sum                      # 获取文件级的checksum，并与sender进程发送的文件级checksum作比较

renaming .init.gd5hvw to init     # 重命名重组成功的临时文件为目标文件init

###################### 文件重组完成 ###########################

recv_files phase=

generate_files phase=

send_files phase=

send files finished               # sender进程结束，并在sender端输出报告：搜索过程中发现5个匹配块，且都是由16位的hash值匹配出来的，

                                  # 第二层弱检验码检查次数为0，也就是说没有hash值冲突的小概率事件发生。总共传输的纯数据为5140字节

total: matches=  hash_hits=  false_alarms= data=

recv_files phase=

generate_files phase=

recv_files finished               # receiver进程结束

generate_files finished           # generator进程结束

client_run waiting on  

sent  bytes  received  bytes  2124.40 bytes/sec  # sender端总共发送5232字节，其中包括纯数据5140字节和非文件数据，接收到79字节

total size is   speedup is 1.63

[sender] _exit_cleanup(code=, file=main.c, line=): entered

[sender] _exit_cleanup(code=, file=main.c, line=): about to call exit()