linux内核sk_buff的结构分析

你的名字 2023-07-25 09:55 41阅读 0赞

### [linux内核sk\_buff的结构分析][linux_sk_buff] ###

我看的内核版本是2.6.32.   
  
在内核中sk\_buff表示一个网络数据包，它是一个双向链表，而链表头就是sk\_buff\_head,在老的内核里面sk\_buff会有一个list域直接指向sk\_buff\_head也就是链表头，现在在2.6.32里面这个域已经被删除了。   
  
而sk\_buff的内存布局可以分作3个段，第一个就是sk\_buff自身，第二个是linear-data buff,第三个是paged-data buff（也就是skb\_shared\_info）。   
  
  
  
ok.我们先来看sk\_buff\_head的结构。它也就是所有sk\_buff的头。

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff\_head \{  
2.      /\* These two members must be first. \*/  
3.      struct sk\_buff  \*next;  
4.      struct sk\_buff  \*prev;  
5.    
6.      \_\_u32       qlen;  
7.      spinlock\_t  lock;  
8.  \};

这里可以看到前两个域是和sk\_buff一致的，而且内核的注释是必须放到最前面。这里的原因是：   
  
这使得两个不同的结构可以放到同一个链表中，尽管sk\_buff\_head要比sk\_buff小巧的多。另外，相同的函数可以同样应用于sk\_buff和sk\_buff\_head。   
  
然后qlen域表示了当前的sk\_buff链上包含多少个skb。   
  
lock域是自旋锁。   
  
然后我们来看sk\_buff，下面就是skb的结构：   
  
我这里注释了一些简单的域，复杂的域下面会单独解释。

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff \{  
2.      /\* These two members must be first. \*/  
3.      struct sk\_buff      \*next;  
4.      struct sk\_buff      \*prev;  
5.    
6.  //表示从属于那个socket，主要是被4层用到。  
7.      struct sock     \*sk;  
8.  //表示这个skb被接收的时间。  
9.      ktime\_t         tstamp;  
10. //这个表示一个网络设备，当skb为输出时它表示skb将要输出的设备，当接收时，它表示输入设备。要注意，这个设备有可能会是虚拟设备(在3层以上看来)  
11.     struct net\_device   \*dev;  
12. ///这里其实应该是dst\_entry类型，不知道为什么内核要改为ul。这个域主要用于路由子系统。这个数据结构保存了一些路由相关信息  
13.     unsigned **long**       \_skb\_dst;  
14. \#ifdef CONFIG\_XFRM  
15.     struct  sec\_path    \*sp;  
16. \#endif  
17. ///这个域很重要，我们下面会详细说明。这里只需要知道这个域是保存每层的控制信息的就够了。  
18.     **char**            cb\[48\];  
19. ///这个长度表示当前的skb中的数据的长度，这个长度即包括buf中的数据也包括切片的数据，也就是保存在skb\_shared\_info中的数据。这个值是会随着从一层到另一层而改变的。下面我们会对比这几个长度的。  
20.     unsigned **int**        len,  
21. ///这个长度只表示切片数据的长度，也就是skb\_shared\_info中的长度。  
22.                 data\_len;  
23. ///这个长度表示mac头的长度(2层的头的长度)  
24.     \_\_u16           mac\_len,  
25. ///这个主要用于clone的时候，它表示clone的skb的头的长度。  
26.                 hdr\_len;  
27.   
28. ///接下来是校验相关的域。  
29.     union \{  
30.         \_\_wsum      csum;  
31.         struct \{  
32.             \_\_u16   csum\_start;  
33.             \_\_u16   csum\_offset;  
34.         \};  
35.     \};  
36. ///优先级，主要用于QOS。  
37.     \_\_u32           priority;  
38.     kmemcheck\_bitfield\_begin(flags1);  
39. ///接下来是一些标志位。  
40. //首先是是否可以本地切片的标志。  
41.     \_\_u8            local\_df:1,  
42. ///为1说明头可能被clone。  
43.                 cloned:1,  
44. ///这个表示校验相关的一个标记,表示硬件驱动是否为我们已经进行了校验(前面的blog有介绍)  
45.                 ip\_summed:2,  
46. ///这个域如果为1,则说明这个skb的头域指针已经分配完毕，因此这个时候计算头的长度只需要head和data的差就可以了。  
47.                 nohdr:1,  
48. ///这个域不太理解什么意思。  
49.                 nfctinfo:3;  
50.   
51. ///pkt\_type主要是表示数据包的类型，比如多播，单播，回环等等。  
52.     \_\_u8            pkt\_type:3,  
53. ///这个域是一个clone标记。主要是在fast clone中被设置，我们后面讲到fast clone时会详细介绍这个域。  
54.                 fclone:2,  
55. ///ipvs拥有的域。  
56.                 ipvs\_property:1,  
57. ///这个域应该是udp使用的一个域。表示只是查看数据。  
58.                 peeked:1,  
59. ///netfilter使用的域。是一个trace 标记  
60.                 nf\_trace:1;  
61. ///这个表示L3层的协议。比如IP,IPV6等等。  
62.     \_\_be16          protocol:16;  
63.     kmemcheck\_bitfield\_end(flags1);  
64. ///skb的析构函数，一般都是设置为sock\_rfree或者sock\_wfree.  
65.     **void**            (\*destructor)(struct sk\_buff \*skb);  
66.   
67. ///netfilter相关的域。  
68. \#**if** defined(CONFIG\_NF\_CONNTRACK) || defined(CONFIG\_NF\_CONNTRACK\_MODULE)  
69.     struct nf\_conntrack \*nfct;  
70.     struct sk\_buff      \*nfct\_reasm;  
71. \#endif  
72. \#ifdef CONFIG\_BRIDGE\_NETFILTER  
73.     struct nf\_bridge\_info   \*nf\_bridge;  
74. \#endif  
75.   
76. ///接收设备的index。  
77.     **int**         iif;  
78.   
79. ///流量控制的相关域。  
80. \#ifdef CONFIG\_NET\_SCHED  
81.     \_\_u16           tc\_index;   /\* traffic control index \*/  
82. \#ifdef CONFIG\_NET\_CLS\_ACT  
83.     \_\_u16           tc\_verd;    /\* traffic control verdict \*/  
84. \#endif  
85. \#endif  
86.   
87.     kmemcheck\_bitfield\_begin(flags2);  
88. ///多队列设备的映射，也就是说映射到那个队列。  
89.     \_\_u16           queue\_mapping:16;  
90. \#ifdef CONFIG\_IPV6\_NDISC\_NODETYPE  
91.     \_\_u8            ndisc\_nodetype:2;  
92. \#endif  
93.     kmemcheck\_bitfield\_end(flags2);  
94.   
95.     /\* 0/14 bit hole \*/  
96.   
97. \#ifdef CONFIG\_NET\_DMA  
98.     dma\_cookie\_t        dma\_cookie;  
99. \#endif  
100. \#ifdef CONFIG\_NETWORK\_SECMARK  
101.     \_\_u32           secmark;  
102. \#endif  
103. ///skb的标记。  
104.     \_\_u32           mark;  
105.   
106. ///vlan的控制tag。  
107.     \_\_u16           vlan\_tci;  
108.   
109. ///传输层的头  
110.     sk\_buff\_data\_t      transport\_header;  
111. ///网络层的头  
112.     sk\_buff\_data\_t      network\_header;  
113. ///链路层的头。  
114.     sk\_buff\_data\_t      mac\_header;  
115. ///接下来就是几个操作skb数据的指针。下面会详细介绍。  
116.     sk\_buff\_data\_t      tail;  
117.     sk\_buff\_data\_t      end;  
118.     unsigned **char**       \*head,  
119.                 \*data;  
120. ///这个表示整个skb的大小，包括skb本身，以及数据。  
121.     unsigned **int**        truesize;  
122. ///skb的引用计数  
123.     atomic\_t        users;  
124. \};

我们来看前面没有解释的那些域。   
  
先来看cb域，他保存了每层所独自需要的内部数据。我们来看tcp的例子。   
  
我们知道tcp层的控制信息保存在tcp\_skb\_cb中，因此来看内核提供的宏来存取这个数据结构：

Java代码   ![收藏代码][icon_star.png]

1.  \#define TCP\_SKB\_CB(\_\_skb)  ((struct tcp\_skb\_cb \*)&((\_\_skb)->cb\[0\]))

在ip层的话，我们可能会用cb来存取切片好的帧。

Java代码   ![收藏代码][icon_star.png]

1.  \#define FRAG\_CB(skb)    ((struct ipfrag\_skb\_cb \*)((skb)->cb))

到这里你可能会问如果我们想要在到达下一层后，还想保存当前层的私有信息怎么办。这个时候我们就可以使用skb的clone了。也就是之只复制sk\_buff结构。   
  
然后我们来看几个比较比较重要的域 len,data,tail,head,end。   
  
这几个域都很简单，下面这张图表示了buffer从tcp层到链路层的过程中len，head，data，tail以及end的变化，通过这个图我们可以非常清晰的了解到这几个域的区别。   
  
  
![1c960c2d-8b20-35fa-87d0-4792ab019efd.jpeg][]   
  
可以很清楚的看到head指针为分配的buffer的起始位置，end为结束位置，而data为当前数据的起始位置，tail为当前数据的结束位置。len就是数据区的长度。   
  
然后来看transport\_header，network\_header以及mac\_header的变化，这几个指针都是随着数据包到达不同的层次才会有对应的值，我们来看下面的图，这个图表示了当从2层到达3层对应的指针的变化。   
  
  
![eb115fcb-7417-345f-a4dc-d38b6e36686b.jpeg][]   
  
这里可以看到data指针会由于数据包到了三层，而跳过2层的头。这里我们就可以得到data起始真正指的是本层的头以及数据的起始位置。   
  
然后我们来看skb的几个重要操作函数。   
  
首先是skb\_put,skb\_push,skb\_pull以及skb\_reserve这几个最长用的操作data指针的函数。   
  
这里可以看到内核skb\_XXX都还有一个\_\_skb\_XXX函数，这是因为前一个只是将后一个函数进行了一个包装，加了一些校验。   
  
先来看\_\_skb\_put函数。   
可以看到它只是将tail指针移动len个位置，然后len也相应的增加len个大小。

Java代码   ![收藏代码][icon_star.png]

1.  **static** inline unsigned **char** \*\_\_skb\_put(struct sk\_buff \*skb, unsigned **int** len)  
2.  \{  
3.      unsigned **char** \*tmp = skb\_tail\_pointer(skb);  
4.      SKB\_LINEAR\_ASSERT(skb);  
5.  ///改变相应的域。  
6.      skb->tail += len;  
7.      skb->len  += len;  
8.      **return** tmp;  
9.  \}

然后是\_\_skb\_push,它是将data指针向上移动len个位置，对应的len肯定也是增加len大小。

Java代码   ![收藏代码][icon_star.png]

1.  **static** inline unsigned **char** \*\_\_skb\_push(struct sk\_buff \*skb, unsigned **int** len)  
2.  \{  
3.      skb->data -= len;  
4.      skb->len  += len;  
5.      **return** skb->data;  
6.  \}

剩下的两个就不贴代码了，都是很简单的函数，\_\_skb\_pull是将data指针向下移动len个位置，然后len减小len大小。\_\_skb\_reserve是将整个数据区，也就是data以及tail指针一起向下移动len大小。这个函数一般是用来对齐地址用的。   
  
看下面的图，描述了4个函数的操作：   
  
  
![a81f6663-9ebb-38b3-9470-35edc2835611.jpeg][]   
  
接着是skb的alloc函数。   
  
在内核中分配一个skb是在\_\_alloc\_skb中实现的，接下来我们就来看这个函数的具体实现。   
  
这个函数起始可以看作三部分，第一部分是从cache中分配内存，第二部分是初始化分配的skb的相关域。第三部分是处理fclone。   
  
还有一个要注意的就是这里\_\_alloc\_skb是被三个函数包装后才能直接使用的，我们只看前两个，一个是skb\_alloc\_skb,一个是alloc\_skb\_fclone函数，这两个函数传递进来的第三个参数，也就是fclone前一个是0,后一个是1.   
  
那么这个函数是什么意思呢，它和alloc\_skb有什么区别的。   
  
这个函数可以叫做Fast SKB cloning函数，这个函数存在的主要原因是，以前我们每次skb\_clone一个skb的时候，都是要调用kmem\_cache\_alloc从cache中alloc一块新的内存。而现在当我们拥有了fast clone之后，通过调用alloc\_skb\_fclone函数来分配一块大于sizeof(struct sk\_buff)的内存，也就是在这次请求的skb的下方多申请了一些内存，然后返回的时候设置返回的skb的fclone标记为SKB\_FCLONE\_ORIG，而多申请的那块内存的sk\_buff的fclone为SKB\_FCLONE\_UNAVAILABLE，这样当我们调用skb\_clone克隆这个skb的时候看到fclone的标记就可以直接将skb的指针+1,而不需要从cache中取了。这样的话节省了一次内存存取，提高了clone的效率，不过调用flcone 一般都是我们确定接下来这个skb会被clone很多次。   
  
更详细的fclone的介绍可以看这里：   
  
http://lwn.net/Articles/140552/   
  
这样我们先来看\_alloc\_skb,然后紧接着看skb\_clone,这样就能更好的理解这些。   
  
这里fclone的多分配的内存部分，没太弄懂从那里多分配的，自己对内核的内存子系统还是不太熟悉。觉得应该是skbuff\_fclone\_cache中会自动多分配些内存。

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff \*\_\_alloc\_skb(unsigned **int** size, gfp\_t gfp\_mask,  
2.                  **int** fclone, **int** node)  
3.  \{  
4.      struct kmem\_cache \*cache;  
5.      struct skb\_shared\_info \*shinfo;  
6.      struct sk\_buff \*skb;  
7.      u8 \*data;  
8.    
9.  ///这里通过fclone的值来判断是要从fclone cache还是说从head cache中取。  
10.     cache = fclone ? skbuff\_fclone\_cache : skbuff\_head\_cache;  
11.   
12. ///首先是分配skb，也就是包头。  
13.     skb = kmem\_cache\_alloc\_node(cache, gfp\_mask & ~\_\_GFP\_DMA, node);  
14.     **if** (!skb)  
15.         **goto** out;  
16. ///首先将size对齐，这里是按一级缓存的大小来对齐。  
17.     size = SKB\_DATA\_ALIGN(size);  
18. ///然后是数据区的大小，大小为size+ sizeof(struct skb\_shared\_info的大小。  
19.     data = kmalloc\_node\_track\_caller(size + sizeof(struct skb\_shared\_info),  
20.             gfp\_mask, node);  
21.     **if** (!data)  
22.         **goto** nodata;  
23.   
24. ///初始化相关域。  
25.     memset(skb, 0, offsetof(struct sk\_buff, tail));  
26. ///这里truesize可以看到就是我们分配的整个skb+data的大小  
27.     skb->truesize = size + sizeof(struct sk\_buff);  
28. ///users加一。  
29.     atomic\_set(&skb->users, 1);  
30. ///一开始head和data是一样大的。  
31.     skb->head = data;  
32.     skb->data = data;  
33. ///设置tail指针  
34.     skb\_reset\_tail\_pointer(skb);  
35. ///一开始tail也就是和data是相同的。  
36.     skb->end = skb->tail + size;  
37.     kmemcheck\_annotate\_bitfield(skb, flags1);  
38.     kmemcheck\_annotate\_bitfield(skb, flags2);  
39. \#ifdef NET\_SKBUFF\_DATA\_USES\_OFFSET  
40.     skb->mac\_header = ~0U;  
41. \#endif  
42.   
43. ///初始化shinfo,这个我就不介绍了，前面的blog分析切片时，这个结构很详细的分析过了。  
44.     shinfo = skb\_shinfo(skb);  
45.     atomic\_set(&shinfo->dataref, 1);  
46.     shinfo->nr\_frags  = 0;  
47.     shinfo->gso\_size = 0;  
48.     shinfo->gso\_segs = 0;  
49.     shinfo->gso\_type = 0;  
50.     shinfo->ip6\_frag\_id = 0;  
51.     shinfo->tx\_flags.flags = 0;  
52.     skb\_frag\_list\_init(skb);  
53.     memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));  
54.   
55. ///fclone为1,说明多分配了一块内存，因此需要设置对应的fclone域。  
56.     **if** (fclone) \{  
57. ///可以看到多分配的内存刚好在当前的skb的下方。  
58.         struct sk\_buff \*child = skb + 1;  
59.         atomic\_t \*fclone\_ref = (atomic\_t \*) (child + 1);  
60.   
61.         kmemcheck\_annotate\_bitfield(child, flags1);  
62.         kmemcheck\_annotate\_bitfield(child, flags2);  
63. ///设置标记。这里要注意，当前的skb和多分配的skb设置的fclone是不同的。  
64.         skb->fclone = SKB\_FCLONE\_ORIG;  
65.         atomic\_set(fclone\_ref, 1);  
66.   
67.         child->fclone = SKB\_FCLONE\_UNAVAILABLE;  
68.     \}  
69. out:  
70.     **return** skb;  
71. nodata:  
72.     kmem\_cache\_free(cache, skb);  
73.     skb = NULL;  
74.     **goto** out;  
75. \}

下图就是alloc\_skb之后的skb的指针的状态。这里忽略了fclone。   
  
![8044f774-98d1-3bd0-8ba6-c850296ed1f6.jpeg][]   
  
  
然后我们来看skb\_clone函数，clone的意思就是只复制skb而不复制data域。   
  
这里它会先判断将要被clone的skb的fclone段，以便与决定是否重新分配一块内存来保存skb。   
  
然后调用\_\_skb\_clone来初始化相关的域。

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff \*skb\_clone(struct sk\_buff \*skb, gfp\_t gfp\_mask)  
2.  \{  
3.      struct sk\_buff \*n;  
4.    
5.  ///n为skb紧跟着那块内存，这里如果skb是通过skb\_fclone分配的，那么n就是一个skb。  
6.      n = skb + 1;  
7.  ///skb和n的fclone都要符合要求，可以看到这里的值就是我们在\_\_alloc\_skb中设置的值。  
8.      **if** (skb->fclone == SKB\_FCLONE\_ORIG &&  
9.          n->fclone == SKB\_FCLONE\_UNAVAILABLE) \{  
10. ///到这里，就说明我们不需要alloc一个skb，直接取n就可以了，并且设置fclone的标记。并修改引用计数。  
11.         atomic\_t \*fclone\_ref = (atomic\_t \*) (n + 1);  
12.         n->fclone = SKB\_FCLONE\_CLONE;  
13.         atomic\_inc(fclone\_ref);  
14.     \} **else** \{  
15.   
16. ///这里就需要从cache中取得一块内存。  
17.         n = kmem\_cache\_alloc(skbuff\_head\_cache, gfp\_mask);  
18.         **if** (!n)  
19.             **return** NULL;  
20.   
21.         kmemcheck\_annotate\_bitfield(n, flags1);  
22.         kmemcheck\_annotate\_bitfield(n, flags2);  
23. ///设置新的skb的fclone域。这里我们新建的skb，没有被fclone的都是这个标记。  
24.         n->fclone = SKB\_FCLONE\_UNAVAILABLE;  
25.     \}  
26.   
27.     **return** \_\_skb\_clone(n, skb);  
28. \}

这里\_\_skb\_clone就不介绍了，函数就是将要被clone的skb的域赋值给clone的skb。   
  
下图就是skb\_clone之后的两个skb的结构图：   
  
![771b4885-55eb-3e47-88ae-fa814de947a7.jpeg][]   
  
当一个skb被clone之后，这个skb的数据区是不能被修改的，这就意为着，我们存取数据不需要任何锁。可是有时我们需要修改数据区，这个时候会有两个选择，一个是我们只修改linear段，也就是head和end之间的段，一种是我们还要修改切片数据，也就是skb\_shared\_info.   
  
这样就有两个函数供我们选择，第一个是pskb\_copy,第二个是skb\_copy.   
  
我们先来看pskb\_copy,函数先alloc一个新的skb，然后调用skb\_copy\_from\_linear\_data来复制线性区的数据。

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff \*pskb\_copy(struct sk\_buff \*skb, gfp\_t gfp\_mask)  
2.  \{  
3.      /\* 
4.       \*  Allocate the copy buffer 
5.       \*/  
6.      struct sk\_buff \*n;  
7.  \#ifdef NET\_SKBUFF\_DATA\_USES\_OFFSET  
8.      n = alloc\_skb(skb->end, gfp\_mask);  
9.  \#**else**  
10.     n = alloc\_skb(skb->end - skb->head, gfp\_mask);  
11. \#endif  
12.     **if** (!n)  
13.         **goto** out;  
14.   
15.     /\* Set the data pointer \*/  
16.     skb\_reserve(n, skb->data - skb->head);  
17.     /\* Set the tail pointer and length \*/  
18.     skb\_put(n, skb\_headlen(skb));  
19. ///复制线性数据段。  
20.     skb\_copy\_from\_linear\_data(skb, n->data, n->len);  
21. ///更新相关域  
22.     n->truesize += skb->data\_len;  
23.     n->data\_len  = skb->data\_len;  
24.     n->len        = skb->len;  
25.   
26. ///下面只是复制切片数据的指针  
27. **if** (skb\_shinfo(skb)->nr\_frags) \{  
28.         **int** i;  
29.   
30.         **for** (i = 0; i < skb\_shinfo(skb)->nr\_frags; i++) \{  
31.             skb\_shinfo(n)->frags\[i\] = skb\_shinfo(skb)->frags\[i\];  
32.             get\_page(skb\_shinfo(n)->frags\[i\].page);  
33.         \}  
34.         skb\_shinfo(n)->nr\_frags = i;  
35.     \}  
36.   
37. ...............................  
38.     copy\_skb\_header(n, skb);  
39. out:  
40.     **return** n;  
41. \}

然后是skb\_copy,它是复制skb的所有数据段，包括切片数据：

Java代码   ![收藏代码][icon_star.png]

1.  struct sk\_buff \*skb\_copy(**const** struct sk\_buff \*skb, gfp\_t gfp\_mask)  
2.  \{  
3.      **int** headerlen = skb->data - skb->head;  
4.      /\* 
5.       \*  Allocate the copy buffer 
6.       \*/  
7.  //先alloc一个新的skb  
8.      struct sk\_buff \*n;  
9.  \#ifdef NET\_SKBUFF\_DATA\_USES\_OFFSET  
10.     n = alloc\_skb(skb->end + skb->data\_len, gfp\_mask);  
11. \#**else**  
12.     n = alloc\_skb(skb->end - skb->head + skb->data\_len, gfp\_mask);  
13. \#endif  
14.     **if** (!n)  
15.         **return** NULL;  
16.   
17.     /\* Set the data pointer \*/  
18.     skb\_reserve(n, headerlen);  
19.     /\* Set the tail pointer and length \*/  
20.     skb\_put(n, skb->len);  
21. ///然后复制所有的数据。  
22.     **if** (skb\_copy\_bits(skb, -headerlen, n->head, headerlen + skb->len))  
23.         BUG();  
24.   
25.     copy\_skb\_header(n, skb);  
26.     **return** n;  
27. \}

下面这张图就表示了psb\_copy和skb\_copy调用后的内存模型，其中a是pskb\_copy,b是skb\_copy:   
  
  
![82caf5a3-b192-39f6-a7c0-c9ea77eb1169.jpeg][]   
  
  
最后来看skb的释放：   
这里主要是判断一个引用标记位users,将它减一，如果大于0则直接返回，否则释放skb。

Java代码   ![收藏代码][icon_star.png]

1.  **void** kfree\_skb(struct sk\_buff \*skb)  
2.  \{  
3.      **if** (unlikely(!skb))  
4.          **return**;  
5.      **if** (likely(atomic\_read(&skb->users) == 1))  
6.          smp\_rmb();  
7.  ///减一，然后判断。  
8.      **else** **if** (likely(!atomic\_dec\_and\_test(&skb->users)))  
9.          **return**;  
10.     trace\_kfree\_skb(skb, \_\_builtin\_return\_address(0));  
11.     \_\_kfree\_skb(skb);  
12. \}

*  [查看图片附件][Link 1]

[linux_sk_buff]: http://simohayha.iteye.com/blog/556168
[icon_star.png]: /images/20230528/2053d4690d68401b9ca99a8966dfc690.png
[1c960c2d-8b20-35fa-87d0-4792ab019efd.jpeg]: /images/20230528/51c9f06f33ca47abb024f399ca0b5584.png
[eb115fcb-7417-345f-a4dc-d38b6e36686b.jpeg]: /images/20230528/2cc8a6968c014012b60f6b7d64f54b79.png
[a81f6663-9ebb-38b3-9470-35edc2835611.jpeg]: /images/20230528/fc1cbf44515443fabd053b736899618b.png
[8044f774-98d1-3bd0-8ba6-c850296ed1f6.jpeg]: /images/20230528/aed876d083f44688b3c5ff785b8438e1.png
[771b4885-55eb-3e47-88ae-fa814de947a7.jpeg]: /images/20230528/44d158fe0f824e46a6de1f6fe37168fc.png
[82caf5a3-b192-39f6-a7c0-c9ea77eb1169.jpeg]: /images/20230528/1dc296ef4ec14ebb81f348a86c655f77.png
[Link 1]: http://simohayha.iteye.com/blog/556168#