Print this page
3942 inject sanity into ipadm tcp buffer size properties
3943 _snd_lowat_fraction tcp tunable has no effect
Reviewed by: Adam Leventhal <ahl@delphix.com>
Reviewed by: Peng Dai <peng.dai@delphix.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/inet/sctp/sctp_tunables.c
+++ new/usr/src/uts/common/inet/sctp/sctp_tunables.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24 + * Copyright (c) 2013 by Delphix. All rights reserved.
24 25 */
25 26
26 27 #include <inet/ip.h>
27 28 #include <inet/ip6.h>
28 29 #include <inet/sctp/sctp_stack.h>
29 30 #include <inet/sctp/sctp_impl.h>
30 31 #include <sys/sunddi.h>
31 32
32 33 /* Max size IP datagram is 64k - 1 */
33 34 #define SCTP_MSS_MAX_IPV4 (IP_MAXPACKET - (sizeof (ipha_t) + \
34 35 sizeof (sctp_hdr_t)))
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
35 36 #define SCTP_MSS_MAX_IPV6 (IP_MAXPACKET - (sizeof (ip6_t) + \
36 37 sizeof (sctp_hdr_t)))
37 38 /* Max of the above */
38 39 #define SCTP_MSS_MAX SCTP_MSS_MAX_IPV4
39 40
40 41 /*
41 42 * returns the current list of listener limit configuration.
42 43 */
43 44 /* ARGSUSED */
44 45 static int
45 -sctp_listener_conf_get(void *cbarg, mod_prop_info_t *pinfo, const char *ifname,
46 - void *val, uint_t psize, uint_t flags)
46 +sctp_listener_conf_get(netstack_t *stack, mod_prop_info_t *pinfo,
47 + const char *ifname, void *val, uint_t psize, uint_t flags)
47 48 {
48 - sctp_stack_t *sctps = (sctp_stack_t *)cbarg;
49 + sctp_stack_t *sctps = stack->netstack_sctp;
49 50 sctp_listener_t *sl;
50 51 char *pval = val;
51 52 size_t nbytes = 0, tbytes = 0;
52 53 uint_t size;
53 54 int err = 0;
54 55
55 56 bzero(pval, psize);
56 57 size = psize;
57 58
58 59 if (flags & (MOD_PROP_DEFAULT|MOD_PROP_PERM|MOD_PROP_POSSIBLE))
59 60 return (0);
60 61
61 62 mutex_enter(&sctps->sctps_listener_conf_lock);
62 63 for (sl = list_head(&sctps->sctps_listener_conf); sl != NULL;
63 64 sl = list_next(&sctps->sctps_listener_conf, sl)) {
64 65 if (psize == size)
65 66 nbytes = snprintf(pval, size, "%d:%d", sl->sl_port,
66 67 sl->sl_ratio);
67 68 else
68 69 nbytes = snprintf(pval, size, ",%d:%d", sl->sl_port,
69 70 sl->sl_ratio);
70 71 size -= nbytes;
71 72 pval += nbytes;
72 73 tbytes += nbytes;
73 74 if (tbytes >= psize) {
74 75 /* Buffer overflow, stop copying information */
75 76 err = ENOBUFS;
76 77 break;
77 78 }
78 79 }
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
79 80
80 81 mutex_exit(&sctps->sctps_listener_conf_lock);
81 82 return (err);
82 83 }
83 84
84 85 /*
85 86 * add a new listener limit configuration.
86 87 */
87 88 /* ARGSUSED */
88 89 static int
89 -sctp_listener_conf_add(void *cbarg, cred_t *cr, mod_prop_info_t *pinfo,
90 +sctp_listener_conf_add(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo,
90 91 const char *ifname, const void* pval, uint_t flags)
91 92 {
92 93 sctp_listener_t *new_sl;
93 94 sctp_listener_t *sl;
94 95 long lport;
95 96 long ratio;
96 97 char *colon;
97 - sctp_stack_t *sctps = (sctp_stack_t *)cbarg;
98 + sctp_stack_t *sctps = stack->netstack_sctp;
98 99
99 100 if (flags & MOD_PROP_DEFAULT)
100 101 return (ENOTSUP);
101 102
102 103 if (ddi_strtol(pval, &colon, 10, &lport) != 0 || lport <= 0 ||
103 104 lport > USHRT_MAX || *colon != ':') {
104 105 return (EINVAL);
105 106 }
106 107 if (ddi_strtol(colon + 1, NULL, 10, &ratio) != 0 || ratio <= 0)
107 108 return (EINVAL);
108 109
109 110 mutex_enter(&sctps->sctps_listener_conf_lock);
110 111 for (sl = list_head(&sctps->sctps_listener_conf); sl != NULL;
111 112 sl = list_next(&sctps->sctps_listener_conf, sl)) {
112 113 /* There is an existing entry, so update its ratio value. */
113 114 if (sl->sl_port == lport) {
114 115 sl->sl_ratio = ratio;
115 116 mutex_exit(&sctps->sctps_listener_conf_lock);
116 117 return (0);
117 118 }
118 119 }
119 120
120 121 if ((new_sl = kmem_alloc(sizeof (sctp_listener_t), KM_NOSLEEP)) ==
121 122 NULL) {
122 123 mutex_exit(&sctps->sctps_listener_conf_lock);
123 124 return (ENOMEM);
124 125 }
125 126
126 127 new_sl->sl_port = lport;
127 128 new_sl->sl_ratio = ratio;
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
128 129 list_insert_tail(&sctps->sctps_listener_conf, new_sl);
129 130 mutex_exit(&sctps->sctps_listener_conf_lock);
130 131 return (0);
131 132 }
132 133
133 134 /*
134 135 * remove a listener limit configuration.
135 136 */
136 137 /* ARGSUSED */
137 138 static int
138 -sctp_listener_conf_del(void *cbarg, cred_t *cr, mod_prop_info_t *pinfo,
139 +sctp_listener_conf_del(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo,
139 140 const char *ifname, const void* pval, uint_t flags)
140 141 {
141 142 sctp_listener_t *sl;
142 143 long lport;
143 - sctp_stack_t *sctps = (sctp_stack_t *)cbarg;
144 + sctp_stack_t *sctps = stack->netstack_sctp;
144 145
145 146 if (flags & MOD_PROP_DEFAULT)
146 147 return (ENOTSUP);
147 148
148 149 if (ddi_strtol(pval, NULL, 10, &lport) != 0 || lport <= 0 ||
149 150 lport > USHRT_MAX) {
150 151 return (EINVAL);
151 152 }
152 153 mutex_enter(&sctps->sctps_listener_conf_lock);
153 154 for (sl = list_head(&sctps->sctps_listener_conf); sl != NULL;
154 155 sl = list_next(&sctps->sctps_listener_conf, sl)) {
155 156 if (sl->sl_port == lport) {
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
156 157 list_remove(&sctps->sctps_listener_conf, sl);
157 158 mutex_exit(&sctps->sctps_listener_conf_lock);
158 159 kmem_free(sl, sizeof (sctp_listener_t));
159 160 return (0);
160 161 }
161 162 }
162 163 mutex_exit(&sctps->sctps_listener_conf_lock);
163 164 return (ESRCH);
164 165 }
165 166
167 +static int
168 +sctp_set_buf_prop(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo,
169 + const char *ifname, const void *pval, uint_t flags)
170 +{
171 + return (mod_set_buf_prop(stack->netstack_sctp->sctps_propinfo_tbl,
172 + stack, cr, pinfo, ifname, pval, flags));
173 +}
174 +
175 +static int
176 +sctp_get_buf_prop(netstack_t *stack, mod_prop_info_t *pinfo, const char *ifname,
177 + void *val, uint_t psize, uint_t flags)
178 +{
179 + return (mod_get_buf_prop(stack->netstack_sctp->sctps_propinfo_tbl,
180 + stack, pinfo, ifname, val, psize, flags));
181 +}
182 +
166 183 /*
167 184 * All of these are alterable, within the min/max values given, at run time.
168 185 *
169 186 * Note: All those tunables which do not start with "_" are Committed and
170 187 * therefore are public. See PSARC 2010/080.
171 188 */
172 189 mod_prop_info_t sctp_propinfo_tbl[] = {
173 190 { "_max_init_retr", MOD_PROTO_SCTP,
174 191 mod_set_uint32, mod_get_uint32,
175 192 {0, 128, 8}, {8} },
176 193
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
177 194 { "_pa_max_retr", MOD_PROTO_SCTP,
178 195 mod_set_uint32, mod_get_uint32,
179 196 {1, 128, 10}, {10} },
180 197
181 198 { "_pp_max_retr", MOD_PROTO_SCTP,
182 199 mod_set_uint32, mod_get_uint32,
183 200 {1, 128, 5}, {5} },
184 201
185 202 { "_cwnd_max", MOD_PROTO_SCTP,
186 203 mod_set_uint32, mod_get_uint32,
187 - {128, (1<<30), 1024*1024}, {1024*1024} },
204 + {128, ULP_MAX_BUF, 1024*1024}, {1024*1024} },
188 205
189 206 { "smallest_nonpriv_port", MOD_PROTO_SCTP,
190 207 mod_set_uint32, mod_get_uint32,
191 208 {1024, (32*1024), 1024}, {1024} },
192 209
193 210 { "_ipv4_ttl", MOD_PROTO_SCTP,
194 211 mod_set_uint32, mod_get_uint32,
195 212 {1, 255, 64}, {64} },
196 213
197 214 { "_heartbeat_interval", MOD_PROTO_SCTP,
198 215 mod_set_uint32, mod_get_uint32,
199 216 {0, 1*DAYS, 30*SECONDS}, {30*SECONDS} },
200 217
201 218 { "_initial_mtu", MOD_PROTO_SCTP,
202 219 mod_set_uint32, mod_get_uint32,
203 220 {68, 65535, 1500}, {1500} },
204 221
205 222 { "_mtu_probe_interval", MOD_PROTO_SCTP,
206 223 mod_set_uint32, mod_get_uint32,
207 224 {0, 1*DAYS, 10*MINUTES}, {10*MINUTES} },
208 225
209 226 { "_new_secret_interval", MOD_PROTO_SCTP,
210 227 mod_set_uint32, mod_get_uint32,
211 228 {0, 1*DAYS, 2*MINUTES}, {2*MINUTES} },
212 229
213 230 /* tunable - 10 */
214 231 { "_deferred_ack_interval", MOD_PROTO_SCTP,
215 232 mod_set_uint32, mod_get_uint32,
216 233 {10*MS, 1*MINUTES, 100*MS}, {100*MS} },
217 234
218 235 { "_snd_lowat_fraction", MOD_PROTO_SCTP,
219 236 mod_set_uint32, mod_get_uint32,
220 237 {0, 16, 0}, {0} },
221 238
222 239 { "_ignore_path_mtu", MOD_PROTO_SCTP,
223 240 mod_set_boolean, mod_get_boolean,
224 241 {B_FALSE}, {B_FALSE} },
225 242
226 243 { "_initial_ssthresh", MOD_PROTO_SCTP,
227 244 mod_set_uint32, mod_get_uint32,
|
↓ open down ↓ |
30 lines elided |
↑ open up ↑ |
228 245 {1024, UINT32_MAX, SCTP_RECV_HIWATER}, { SCTP_RECV_HIWATER} },
229 246
230 247 { "smallest_anon_port", MOD_PROTO_SCTP,
231 248 mod_set_uint32, mod_get_uint32,
232 249 {1024, ULP_MAX_PORT, 32*1024}, {32*1024} },
233 250
234 251 { "largest_anon_port", MOD_PROTO_SCTP,
235 252 mod_set_uint32, mod_get_uint32,
236 253 {1024, ULP_MAX_PORT, ULP_MAX_PORT}, {ULP_MAX_PORT} },
237 254
238 - { "send_maxbuf", MOD_PROTO_SCTP,
239 - mod_set_uint32, mod_get_uint32,
240 - {SCTP_XMIT_LOWATER, (1<<30), SCTP_XMIT_HIWATER},
255 + { "send_buf", MOD_PROTO_SCTP,
256 + sctp_set_buf_prop, sctp_get_buf_prop,
257 + {SCTP_XMIT_LOWATER, ULP_MAX_BUF, SCTP_XMIT_HIWATER},
241 258 {SCTP_XMIT_HIWATER} },
242 259
243 260 { "_xmit_lowat", MOD_PROTO_SCTP,
244 261 mod_set_uint32, mod_get_uint32,
245 - {SCTP_XMIT_LOWATER, (1<<30), SCTP_XMIT_LOWATER},
262 + {SCTP_XMIT_LOWATER, ULP_MAX_BUF, SCTP_XMIT_LOWATER},
246 263 {SCTP_XMIT_LOWATER} },
247 264
248 - { "recv_maxbuf", MOD_PROTO_SCTP,
249 - mod_set_uint32, mod_get_uint32,
250 - {SCTP_RECV_LOWATER, (1<<30), SCTP_RECV_HIWATER},
265 + { "recv_buf", MOD_PROTO_SCTP,
266 + sctp_set_buf_prop, sctp_get_buf_prop,
267 + {SCTP_RECV_LOWATER, ULP_MAX_BUF, SCTP_RECV_HIWATER},
251 268 {SCTP_RECV_HIWATER} },
252 269
253 - { "_max_buf", MOD_PROTO_SCTP,
270 + { "max_buf", MOD_PROTO_SCTP,
254 271 mod_set_uint32, mod_get_uint32,
255 - {8192, (1<<30), 1024*1024}, {1024*1024} },
272 + {8192, ULP_MAX_BUF, 1024*1024}, {1024*1024} },
256 273
257 274 /* tunable - 20 */
258 275 { "_rtt_updates", MOD_PROTO_SCTP,
259 276 mod_set_uint32, mod_get_uint32,
260 277 {0, 65536, 20}, {20} },
261 278
262 279 { "_ipv6_hoplimit", MOD_PROTO_SCTP,
263 280 mod_set_uint32, mod_get_uint32,
264 281 {0, IPV6_MAX_HOPS, IPV6_DEFAULT_HOPS}, {IPV6_DEFAULT_HOPS} },
265 282
266 283 { "_rto_min", MOD_PROTO_SCTP,
267 284 mod_set_uint32, mod_get_uint32,
268 285 {500*MS, 60*SECONDS, 1*SECONDS}, {1*SECONDS} },
269 286
270 287 { "_rto_max", MOD_PROTO_SCTP,
271 288 mod_set_uint32, mod_get_uint32,
272 289 {1*SECONDS, 60000*SECONDS, 60*SECONDS}, {60*SECONDS} },
273 290
274 291 { "_rto_initial", MOD_PROTO_SCTP,
275 292 mod_set_uint32, mod_get_uint32,
276 293 {1*SECONDS, 60000*SECONDS, 3*SECONDS}, {3*SECONDS} },
277 294
278 295 { "_cookie_life", MOD_PROTO_SCTP,
279 296 mod_set_uint32, mod_get_uint32,
280 297 {10*MS, 60000*SECONDS, 60*SECONDS}, {60*SECONDS} },
281 298
282 299 { "_max_in_streams", MOD_PROTO_SCTP,
283 300 mod_set_uint32, mod_get_uint32,
284 301 {1, UINT16_MAX, 32}, {32} },
285 302
286 303 { "_initial_out_streams", MOD_PROTO_SCTP,
287 304 mod_set_uint32, mod_get_uint32,
288 305 {1, UINT16_MAX, 32}, {32} },
289 306
290 307 { "_shutack_wait_bound", MOD_PROTO_SCTP,
291 308 mod_set_uint32, mod_get_uint32,
292 309 {0, 300*SECONDS, 60*SECONDS}, {60*SECONDS} },
293 310
294 311 { "_maxburst", MOD_PROTO_SCTP,
295 312 mod_set_uint32, mod_get_uint32,
296 313 {2, 8, 4}, {4} },
297 314
298 315 /* tunable - 30 */
299 316 { "_addip_enabled", MOD_PROTO_SCTP,
300 317 mod_set_boolean, mod_get_boolean,
301 318 {B_FALSE}, {B_FALSE} },
302 319
303 320 { "_recv_hiwat_minmss", MOD_PROTO_SCTP,
304 321 mod_set_uint32, mod_get_uint32,
305 322 {1, 65536, 4}, {4} },
306 323
307 324 { "_slow_start_initial", MOD_PROTO_SCTP,
308 325 mod_set_uint32, mod_get_uint32,
309 326 {1, 16, 4}, {4} },
310 327
311 328 { "_slow_start_after_idle", MOD_PROTO_SCTP,
312 329 mod_set_uint32, mod_get_uint32,
313 330 {1, 16384, 4}, {4} },
314 331
315 332 { "_prsctp_enabled", MOD_PROTO_SCTP,
316 333 mod_set_boolean, mod_get_boolean,
317 334 {B_TRUE}, {B_TRUE} },
318 335
319 336 { "_fast_rxt_thresh", MOD_PROTO_SCTP,
320 337 mod_set_uint32, mod_get_uint32,
321 338 {1, 10000, 3}, {3} },
322 339
323 340 { "_deferred_acks_max", MOD_PROTO_SCTP,
324 341 mod_set_uint32, mod_get_uint32,
325 342 { 1, 16, 2}, {2} },
326 343
327 344 /*
328 345 * sctp_wroff_xtra is the extra space in front of SCTP/IP header
329 346 * for link layer header. It has to be a multiple of 8.
330 347 */
331 348 { "_wroff_xtra", MOD_PROTO_SCTP,
332 349 mod_set_aligned, mod_get_uint32,
333 350 {0, 256, 32}, {32} },
334 351
335 352 { "extra_priv_ports", MOD_PROTO_SCTP,
336 353 mod_set_extra_privports, mod_get_extra_privports,
337 354 {1, ULP_MAX_PORT, 0}, {0} },
338 355
339 356 { "_listener_limit_conf", MOD_PROTO_SCTP,
340 357 NULL, sctp_listener_conf_get, {0}, {0} },
341 358
342 359 { "_listener_limit_conf_add", MOD_PROTO_SCTP,
343 360 sctp_listener_conf_add, NULL, {0}, {0} },
344 361
345 362 { "_listener_limit_conf_del", MOD_PROTO_SCTP,
346 363 sctp_listener_conf_del, NULL, {0}, {0} },
347 364
348 365 { "?", MOD_PROTO_SCTP, NULL, mod_get_allprop, {0}, {0} },
349 366
350 367 { NULL, 0, NULL, NULL, {0}, {0} }
351 368 };
352 369
353 370 int sctp_propinfo_count = A_CNT(sctp_propinfo_tbl);
|
↓ open down ↓ |
88 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX