UDP 為什么在不同內核版本表現(xiàn)出來的現(xiàn)象不同呢

sasinop

linux 上的UDP程序

在不同版本的內核上執(zhí)行時，表現(xiàn)出來的現(xiàn)象不一樣，估計是啥原因造成的呢？

程序執(zhí)行后，應該表現(xiàn)如下；
PC端用網絡助手持續(xù)發(fā)命令 A；UDP服務端，解析命令，并返回結果；PC發(fā)送頻率是10ms，服務端處理一次指令要1s, 因此，在服務端會有很多條指令沒有執(zhí)行；此時，PC發(fā)命令B，應該立即將B命令對應結果返回給PC

在linux  內核版本，3.2.0上，沒有問題，持續(xù)發(fā)A ，發(fā)一段時間后，切換為命令B，可以立即返回B的結果。

在linux內核版本為 2.6.8 ，3.5.x的內核上，就不能立即返回B對應的結果�？偸且獔�(zhí)行幾條命令A的結果后，才能返回命令B的結果....，，感覺就是緩存幾條上一個命令

sasinop

現(xiàn)在試了三個版本的內核
2.6.8
3.2.0
3.5.x

程序分別在 2.6，3.2，3.5上編譯， 編譯過的文件，分別在 2.6；3.2；3.5上執(zhí)行，只有在3.2上的執(zhí)行結果是想要的結果
也就說，無論在哪個版本上編譯的程序，在內核3.2上執(zhí)行，結果是想要的
而無論在哪個版本上編譯的程序，在3.2以為的內核上跑，結果都超出意外了...

sasinop

經人提醒，查看內核，以SOCK_MIN_RCVBUF 為關鍵字，凡是有 SOCK_MIN_RCVBUF 關鍵字的文件都對比一遍

發(fā)現(xiàn)有差異：

3.2.0 與2.6.32的差異就在于，SOCK_MIN_RCVBUF 定義的大小
3.2.0與 3.5.0 的差異就在于，在ip_vs_sync.c文件中，3.2.0未做對SOCK_MIN_RCVBUF 的操作；3.5.0里對SOCK_MIN_RCVBUF 作了操作

1. 
   
2. 
   
3. sock.h
   
4. 3.2.0
   
5. #define SOCK_MIN_RCVBUF (2048 + sizeof(struct sk_buff))
   
6. 3.5.0
   
7. #define SOCK_MIN_RCVBUF (2048 + sizeof(struct sk_buff))
   
8. 2.6.32
   
9. #define SOCK_MIN_RCVBUF 256
   
10. 
    
11. Tcp.c
    
12. 
    
13. 3.2.0
    
14. case TCP_WINDOW_CLAMP:
    
15.                 if (!val) {
    
16.                         if (sk->sk_state != TCP_CLOSE) {
    
17.                                 err = -EINVAL;
    
18.                                 break;
    
19.                         }
    
20.                         tp->window_clamp = 0;
    
21.                 } else
    
22.                         tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
    
23.                                                 SOCK_MIN_RCVBUF / 2 : val;
    
24.                 break;
    
25. 
    
26. 3.5.0
    
27. case TCP_WINDOW_CLAMP:
    
28.                 if (!val) {
    
29.                         if (sk->sk_state != TCP_CLOSE) {
    
30.                                 err = -EINVAL;
    
31.                                 break;
    
32.                         }
    
33.                         tp->window_clamp = 0;
    
34.                 } else
    
35.                         tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
    
36.                                                 SOCK_MIN_RCVBUF / 2 : val;
    
37.                 break;
    
38. 
    
39. 
    
40. 2.6.32
    
41. case TCP_WINDOW_CLAMP:
    
42.                 if (!val) {
    
43.                         if (sk->sk_state != TCP_CLOSE) {
    
44.                                 err = -EINVAL;
    
45.                                 break;
    
46.                         }
    
47.                         tp->window_clamp = 0;
    
48.                 } else
    
49.                         tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
    
50.                                                 SOCK_MIN_RCVBUF / 2 : val;
    
51.                 break;
    
52. 
    
53. 
    
54. 
    
55. 
    
56. 
    
57. 
    
58. Sock.c
    
59. 3.2.0
    
60. if ((val * 2) < SOCK_MIN_RCVBUF)
    
61.                         sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
    
62.                 else
    
63.                         sk->sk_rcvbuf = val * 2;
    
64.                 break;
    
65. 3.5.0
    
66. sk->sk_rcvbuf = max_t(u32, val * 2, SOCK_MIN_RCVBUF);
    
67.                 break;
    
68. 2.6.32
    
69. if ((val * 2) < SOCK_MIN_RCVBUF)
    
70.                         sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
    
71.                 else
    
72.                         sk->sk_rcvbuf = val * 2;
    
73.                 break;
    
74. 
    
75. 
    
76. 
    
77. ip_vs_sync.c
    
78. 3.2.0
    
79. //無 SOCK_MIN_RCVBUF內容
    
80. 3.5.0
    
81. static void set_sock_size(struct sock *sk, int mode, int val)
    
82. {
    
83.         /* setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)); */
    
84.         /* setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)); */
    
85.         lock_sock(sk);
    
86.         if (mode) {
    
87.                 val = clamp_t(int, val, (SOCK_MIN_SNDBUF + 1) / 2,
    
88.                               sysctl_wmem_max);
    
89.                 sk->sk_sndbuf = val * 2;
    
90.                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
    
91.         } else {
    
92.                 val = clamp_t(int, val, (SOCK_MIN_RCVBUF + 1) / 2,
    
93.                               sysctl_rmem_max);
    
94.                 sk->sk_rcvbuf = val * 2;
    
95.                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
    
96.         }
    
97.         release_sock(sk);
    
98. }
    
99. 
    
100. 2.6.32
     
101. //無SOCK_MIN_RCVBUF內容
     

復制代碼