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_PATH_MAX_RETRANS, 125 .procname = "path_max_retrans", 126 .data = &sctp_max_retrans_path, 127 .maxlen = sizeof(int), 128 .mode = 0644, 129 .proc_handler = &proc_dointvec 130 }, 131 { 132 .ctl_name = NET_SCTP_MAX_INIT_RETRANSMITS, 133 .procname = "max_init_retransmits", 134 .data = &sctp_max_retrans_init, 135 .maxlen = sizeof(int), 136 .mode = 0644, 137 .proc_handler = &proc_dointvec 138 }, 139 { 140 .ctl_name = NET_SCTP_HB_INTERVAL, 141 .procname = "hb_interval", 142 .data = &sctp_hb_interval, 143 .maxlen = sizeof(long), 144 .mode = 0644, 145 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 146 .strategy = &sctp_sysctl_jiffies_ms, 147 .extra1 = &rto_timer_min, 148 .extra2 = &rto_timer_max 149 }, 150 { 151 .ctl_name = NET_SCTP_PRESERVE_ENABLE, 152 .procname = "cookie_preserve_enable", 153 .data = &sctp_cookie_preserve_enable, 154 .maxlen = sizeof(long), 155 .mode = 0644, 156 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 157 .strategy = &sctp_sysctl_jiffies_ms, 158 .extra1 = &rto_timer_min, 159 .extra2 = &rto_timer_max 160 }, 161 { 162 .ctl_name = NET_SCTP_RTO_ALPHA, 163 .procname = "rto_alpha_exp_divisor", 164 .data = &sctp_rto_alpha, 165 .maxlen = sizeof(int), 166 .mode = 0644, 167 .proc_handler = &proc_dointvec 168 }, 169 { 170 .ctl_name = NET_SCTP_RTO_BETA, 171 .procname = "rto_beta_exp_divisor", 172 .data = &sctp_rto_beta, 173 .maxlen = sizeof(int), 174 .mode = 0644, 175 .proc_handler = &proc_dointvec 176 }, 177 { 178 .ctl_name = NET_SCTP_ADDIP_ENABLE, 179 .procname = "addip_enable", 180 .data = &sctp_addip_enable, 181 .maxlen = sizeof(int), 182 .mode = 0644, 183 .proc_handler = &proc_dointvec 184 }, 185 { 186 .ctl_name = NET_SCTP_PRSCTP_ENABLE, 187 .procname = "prsctp_enable", 188 .data = &sctp_prsctp_enable, 189 .maxlen = sizeof(int), 190 .mode = 0644, 191 .proc_handler = &proc_dointvec 192 }, 193 { 194 .ctl_name = NET_SCTP_SACK_TIMEOUT, 195 .procname = "sack_timeout", 196 .data = &sctp_sack_timeout, 197 .maxlen = sizeof(long), 198 .mode = 0644, 199 .proc_handler = &proc_doulongvec_ms_jiffies_minmax, 200 .strategy = &sctp_sysctl_jiffies_ms, 201 .extra1 = &sack_timer_min, 202 .extra2 = &sack_timer_max, 203 }, 204 { .ctl_name = 0 } 205 }; 206 207 static ctl_table sctp_net_table[] = { 208 { 209 .ctl_name = NET_SCTP, 210 .procname = "sctp", 211 .mode = 0555, 212 .child = sctp_table 213 }, 214 { .ctl_name = 0 } 215 }; 216 217 static ctl_table sctp_root_table[] = { 218 { 219 .ctl_name = CTL_NET, 220 .procname = "net", 221 .mode = 0555, 222 .child = sctp_net_table 223 }, 224 { .ctl_name = 0 } 225 }; 226 227 static struct ctl_table_header * sctp_sysctl_header; 228 229 /* Sysctl registration. */ 230 void sctp_sysctl_register(void) 231 { 232 sctp_sysctl_header = register_sysctl_table(sctp_root_table, 0); 233 } 234 235 /* Sysctl deregistration. */ 236 void sctp_sysctl_unregister(void) 237 { 238 unregister_sysctl_table(sctp_sysctl_header); 239 } 240 241 /* Strategy function to convert jiffies to milliseconds. */ 242 static int sctp_sysctl_jiffies_ms(ctl_table *table, int __user *name, int nlen, 243 void __user *oldval, size_t __user *oldlenp, 244 void __user *newval, size_t newlen, void **context) { 245 246 if (oldval) { 247 size_t olen; 248 249 if (oldlenp) { 250 if (get_user(olen, oldlenp)) 251 return -EFAULT; 252 253 if (olen != sizeof (int)) 254 return -EINVAL; 255 } 256 if (put_user((*(int *)(table->data) * 1000) / HZ, 257 (int __user *)oldval) || 258 (oldlenp && put_user(sizeof (int), oldlenp))) 259 return -EFAULT; 260 } 261 if (newval && newlen) { 262 int new; 263 264 if (newlen != sizeof (int)) 265 return -EINVAL; 266 267 if (get_user(new, (int __user *)newval)) 268 return -EFAULT; 269 270 *(int *)(table->data) = (new * HZ) / 1000; 271 } 272 return 1; 273 } 274