1 /* SCTP kernel reference Implementation 2 * (C) Copyright IBM Corp. 2002, 2004 3 * Copyright (c) 2002 Intel Corp. 4 * 5 * This file is part of the SCTP kernel reference Implementation 6 * 7 * Sysctl related interfaces for SCTP. 8 * 9 * The SCTP reference implementation is free software; 10 * you can redistribute it and/or modify it under the terms of 11 * the GNU General Public License as published by 12 * the Free Software Foundation; either version 2, or (at your option) 13 * any later version. 14 * 15 * The SCTP reference implementation is distributed in the hope that it 16 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 17 * ************************ 18 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 19 * See the GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with GNU CC; see the file COPYING. If not, write to 23 * the Free Software Foundation, 59 Temple Place - Suite 330, 24 * Boston, MA 02111-1307, USA. 25 * 26 * Please send any bug reports or fixes you make to the 27 * email address(es): 28 * lksctp developers <lksctp-developers@lists.sourceforge.net> 29 * 30 * Or submit a bug report through the following website: 31 * http://www.sf.net/projects/lksctp 32 * 33 * Written or modified by: 34 * Mingqin Liu <liuming@us.ibm.com> 35 * Jon Grimm <jgrimm@us.ibm.com> 36 * Ardelle Fan <ardelle.fan@intel.com> 37 * Ryan Layer <rmlayer@us.ibm.com> 38 * Sridhar Samudrala <sri@us.ibm.com> 39 * 40 * Any bugs reported given to us we will try to fix... any fixes shared will 41 * be incorporated into the next SCTP release. 42 */ 43 44 #include <net/sctp/structs.h> 45 #include <net/sctp/sctp.h> 46 #include <linux/sysctl.h> 47 48 static ctl_handler sctp_sysctl_jiffies_ms; 49 static long rto_timer_min = 1; 50 static long rto_timer_max = 86400000; /* One day */ 51 static long sack_timer_min = 1; 52 static long sack_timer_max = 500; 53 54 static ctl_table sctp_table[] = { 55 { 56 .ctl_name = NET_SCTP_RTO_INITIAL, 57 .procname = "rto_initial", 58 .data = &sctp_rto_initial, 59 .maxlen = sizeof(long), 60 .mode = 0644, 61 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 62 .strategy = &sctp_sysctl_jiffies_ms, 63 .extra1 = &rto_timer_min, 64 .extra2 = &rto_timer_max 65 }, 66 { 67 .ctl_name = NET_SCTP_RTO_MIN, 68 .procname = "rto_min", 69 .data = &sctp_rto_min, 70 .maxlen = sizeof(long), 71 .mode = 0644, 72 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 73 .strategy = &sctp_sysctl_jiffies_ms, 74 .extra1 = &rto_timer_min, 75 .extra2 = &rto_timer_max 76 }, 77 { 78 .ctl_name = NET_SCTP_RTO_MAX, 79 .procname = "rto_max", 80 .data = &sctp_rto_max, 81 .maxlen = sizeof(long), 82 .mode = 0644, 83 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 84 .strategy = &sctp_sysctl_jiffies_ms, 85 .extra1 = &rto_timer_min, 86 .extra2 = &rto_timer_max 87 }, 88 { 89 .ctl_name = NET_SCTP_VALID_COOKIE_LIFE, 90 .procname = "valid_cookie_life", 91 .data = &sctp_valid_cookie_life, 92 .maxlen = sizeof(long), 93 .mode = 0644, 94 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 95 .strategy = &sctp_sysctl_jiffies_ms, 96 .extra1 = &rto_timer_min, 97 .extra2 = &rto_timer_max 98 }, 99 { 100 .ctl_name = NET_SCTP_MAX_BURST, 101 .procname = "max_burst", 102 .data = &sctp_max_burst, 103 .maxlen = sizeof(int), 104 .mode = 0644, 105 .proc_handler = &proc_dointvec 106 }, 107 { 108 .ctl_name = NET_SCTP_ASSOCIATION_MAX_RETRANS, 109 .procname = "association_max_retrans", 110 .data = &sctp_max_retrans_association, 111 .maxlen = sizeof(int), 112 .mode = 0644, 113 .proc_handler = &proc_dointvec 114 }, 115 { 116 .ctl_name = NET_SCTP_SNDBUF_POLICY, 117 .procname = "sndbuf_policy", 118 .data = &sctp_sndbuf_policy, 119 .maxlen = sizeof(int), 120 .mode = 0644, 121 .proc_handler = &proc_dointvec 122 }, 123 { 124 .ctl_name = NET_SCTP_RCVBUF_POLICY, 125 .procname = "rcvbuf_policy", 126 .data = &sctp_rcvbuf_policy, 127 .maxlen = sizeof(int), 128 .mode = 0644, 129 .proc_handler = &proc_dointvec 130 }, 131 { 132 .ctl_name = NET_SCTP_PATH_MAX_RETRANS, 133 .procname = "path_max_retrans", 134 .data = &sctp_max_retrans_path, 135 .maxlen = sizeof(int), 136 .mode = 0644, 137 .proc_handler = &proc_dointvec 138 }, 139 { 140 .ctl_name = NET_SCTP_MAX_INIT_RETRANSMITS, 141 .procname = "max_init_retransmits", 142 .data = &sctp_max_retrans_init, 143 .maxlen = sizeof(int), 144 .mode = 0644, 145 .proc_handler = &proc_dointvec 146 }, 147 { 148 .ctl_name = NET_SCTP_HB_INTERVAL, 149 .procname = "hb_interval", 150 .data = &sctp_hb_interval, 151 .maxlen = sizeof(long), 152 .mode = 0644, 153 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 154 .strategy = &sctp_sysctl_jiffies_ms, 155 .extra1 = &rto_timer_min, 156 .extra2 = &rto_timer_max 157 }, 158 { 159 .ctl_name = NET_SCTP_PRESERVE_ENABLE, 160 .procname = "cookie_preserve_enable", 161 .data = &sctp_cookie_preserve_enable, 162 .maxlen = sizeof(long), 163 .mode = 0644, 164 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 165 .strategy = &sctp_sysctl_jiffies_ms, 166 .extra1 = &rto_timer_min, 167 .extra2 = &rto_timer_max 168 }, 169 { 170 .ctl_name = NET_SCTP_RTO_ALPHA, 171 .procname = "rto_alpha_exp_divisor", 172 .data = &sctp_rto_alpha, 173 .maxlen = sizeof(int), 174 .mode = 0644, 175 .proc_handler = &proc_dointvec 176 }, 177 { 178 .ctl_name = NET_SCTP_RTO_BETA, 179 .procname = "rto_beta_exp_divisor", 180 .data = &sctp_rto_beta, 181 .maxlen = sizeof(int), 182 .mode = 0644, 183 .proc_handler = &proc_dointvec 184 }, 185 { 186 .ctl_name = NET_SCTP_ADDIP_ENABLE, 187 .procname = "addip_enable", 188 .data = &sctp_addip_enable, 189 .maxlen = sizeof(int), 190 .mode = 0644, 191 .proc_handler = &proc_dointvec 192 }, 193 { 194 .ctl_name = NET_SCTP_PRSCTP_ENABLE, 195 .procname = "prsctp_enable", 196 .data = &sctp_prsctp_enable, 197 .maxlen = sizeof(int), 198 .mode = 0644, 199 .proc_handler = &proc_dointvec 200 }, 201 { 202 .ctl_name = NET_SCTP_SACK_TIMEOUT, 203 .procname = "sack_timeout", 204 .data = &sctp_sack_timeout, 205 .maxlen = sizeof(long), 206 .mode = 0644, 207 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 208 .strategy = &sctp_sysctl_jiffies_ms, 209 .extra1 = &sack_timer_min, 210 .extra2 = &sack_timer_max, 211 }, 212 { .ctl_name = 0 } 213 }; 214 215 static ctl_table sctp_net_table[] = { 216 { 217 .ctl_name = NET_SCTP, 218 .procname = "sctp", 219 .mode = 0555, 220 .child = sctp_table 221 }, 222 { .ctl_name = 0 } 223 }; 224 225 static ctl_table sctp_root_table[] = { 226 { 227 .ctl_name = CTL_NET, 228 .procname = "net", 229 .mode = 0555, 230 .child = sctp_net_table 231 }, 232 { .ctl_name = 0 } 233 }; 234 235 static struct ctl_table_header * sctp_sysctl_header; 236 237 /* Sysctl registration. */ 238 void sctp_sysctl_register(void) 239 { 240 sctp_sysctl_header = register_sysctl_table(sctp_root_table, 0); 241 } 242 243 /* Sysctl deregistration. */ 244 void sctp_sysctl_unregister(void) 245 { 246 unregister_sysctl_table(sctp_sysctl_header); 247 } 248 249 /* Strategy function to convert jiffies to milliseconds. */ 250 static int sctp_sysctl_jiffies_ms(ctl_table *table, int __user *name, int nlen, 251 void __user *oldval, size_t __user *oldlenp, 252 void __user *newval, size_t newlen, void **context) { 253 254 if (oldval) { 255 size_t olen; 256 257 if (oldlenp) { 258 if (get_user(olen, oldlenp)) 259 return -EFAULT; 260 261 if (olen != sizeof (int)) 262 return -EINVAL; 263 } 264 if (put_user((*(int *)(table->data) * 1000) / HZ, 265 (int __user *)oldval) || 266 (oldlenp && put_user(sizeof (int), oldlenp))) 267 return -EFAULT; 268 } 269 if (newval && newlen) { 270 int new; 271 272 if (newlen != sizeof (int)) 273 return -EINVAL; 274 275 if (get_user(new, (int __user *)newval)) 276 return -EFAULT; 277 278 *(int *)(table->data) = (new * HZ) / 1000; 279 } 280 return 1; 281 } 282