~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sctp/sysctl.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SCTP kernel implementation
  2  * (C) Copyright IBM Corp. 2002, 2004
  3  * Copyright (c) 2002 Intel Corp.
  4  *
  5  * This file is part of the SCTP kernel implementation
  6  *
  7  * Sysctl related interfaces for SCTP.
  8  *
  9  * This SCTP 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  * This SCTP 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 <linux-sctp@vger.kernel.org>
 29  *
 30  * Written or modified by:
 31  *    Mingqin Liu           <liuming@us.ibm.com>
 32  *    Jon Grimm             <jgrimm@us.ibm.com>
 33  *    Ardelle Fan           <ardelle.fan@intel.com>
 34  *    Ryan Layer            <rmlayer@us.ibm.com>
 35  *    Sridhar Samudrala     <sri@us.ibm.com>
 36  */
 37 
 38 #include <net/sctp/structs.h>
 39 #include <net/sctp/sctp.h>
 40 #include <linux/sysctl.h>
 41 
 42 static int zero = 0;
 43 static int one = 1;
 44 static int timer_max = 86400000; /* ms in one day */
 45 static int int_max = INT_MAX;
 46 static int sack_timer_min = 1;
 47 static int sack_timer_max = 500;
 48 static int addr_scope_max = 3; /* check sctp_scope_policy_t in include/net/sctp/constants.h for max entries */
 49 static int rwnd_scale_max = 16;
 50 static unsigned long max_autoclose_min = 0;
 51 static unsigned long max_autoclose_max =
 52         (MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
 53         ? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
 54 
 55 extern long sysctl_sctp_mem[3];
 56 extern int sysctl_sctp_rmem[3];
 57 extern int sysctl_sctp_wmem[3];
 58 
 59 static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
 60                                 void __user *buffer, size_t *lenp,
 61                                 loff_t *ppos);
 62 static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
 63                                 void __user *buffer, size_t *lenp,
 64                                 loff_t *ppos);
 65 static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
 66                                 void __user *buffer, size_t *lenp,
 67                                 loff_t *ppos);
 68 
 69 static struct ctl_table sctp_table[] = {
 70         {
 71                 .procname       = "sctp_mem",
 72                 .data           = &sysctl_sctp_mem,
 73                 .maxlen         = sizeof(sysctl_sctp_mem),
 74                 .mode           = 0644,
 75                 .proc_handler   = proc_doulongvec_minmax
 76         },
 77         {
 78                 .procname       = "sctp_rmem",
 79                 .data           = &sysctl_sctp_rmem,
 80                 .maxlen         = sizeof(sysctl_sctp_rmem),
 81                 .mode           = 0644,
 82                 .proc_handler   = proc_dointvec,
 83         },
 84         {
 85                 .procname       = "sctp_wmem",
 86                 .data           = &sysctl_sctp_wmem,
 87                 .maxlen         = sizeof(sysctl_sctp_wmem),
 88                 .mode           = 0644,
 89                 .proc_handler   = proc_dointvec,
 90         },
 91 
 92         { /* sentinel */ }
 93 };
 94 
 95 static struct ctl_table sctp_net_table[] = {
 96         {
 97                 .procname       = "rto_initial",
 98                 .data           = &init_net.sctp.rto_initial,
 99                 .maxlen         = sizeof(unsigned int),
100                 .mode           = 0644,
101                 .proc_handler   = proc_dointvec_minmax,
102                 .extra1         = &one,
103                 .extra2         = &timer_max
104         },
105         {
106                 .procname       = "rto_min",
107                 .data           = &init_net.sctp.rto_min,
108                 .maxlen         = sizeof(unsigned int),
109                 .mode           = 0644,
110                 .proc_handler   = proc_sctp_do_rto_min,
111                 .extra1         = &one,
112                 .extra2         = &init_net.sctp.rto_max
113         },
114         {
115                 .procname       = "rto_max",
116                 .data           = &init_net.sctp.rto_max,
117                 .maxlen         = sizeof(unsigned int),
118                 .mode           = 0644,
119                 .proc_handler   = proc_sctp_do_rto_max,
120                 .extra1         = &init_net.sctp.rto_min,
121                 .extra2         = &timer_max
122         },
123         {
124                 .procname       = "rto_alpha_exp_divisor",
125                 .data           = &init_net.sctp.rto_alpha,
126                 .maxlen         = sizeof(int),
127                 .mode           = 0444,
128                 .proc_handler   = proc_dointvec,
129         },
130         {
131                 .procname       = "rto_beta_exp_divisor",
132                 .data           = &init_net.sctp.rto_beta,
133                 .maxlen         = sizeof(int),
134                 .mode           = 0444,
135                 .proc_handler   = proc_dointvec,
136         },
137         {
138                 .procname       = "max_burst",
139                 .data           = &init_net.sctp.max_burst,
140                 .maxlen         = sizeof(int),
141                 .mode           = 0644,
142                 .proc_handler   = proc_dointvec_minmax,
143                 .extra1         = &zero,
144                 .extra2         = &int_max
145         },
146         {
147                 .procname       = "cookie_preserve_enable",
148                 .data           = &init_net.sctp.cookie_preserve_enable,
149                 .maxlen         = sizeof(int),
150                 .mode           = 0644,
151                 .proc_handler   = proc_dointvec,
152         },
153         {
154                 .procname       = "cookie_hmac_alg",
155                 .maxlen         = 8,
156                 .mode           = 0644,
157                 .proc_handler   = proc_sctp_do_hmac_alg,
158         },
159         {
160                 .procname       = "valid_cookie_life",
161                 .data           = &init_net.sctp.valid_cookie_life,
162                 .maxlen         = sizeof(unsigned int),
163                 .mode           = 0644,
164                 .proc_handler   = proc_dointvec_minmax,
165                 .extra1         = &one,
166                 .extra2         = &timer_max
167         },
168         {
169                 .procname       = "sack_timeout",
170                 .data           = &init_net.sctp.sack_timeout,
171                 .maxlen         = sizeof(int),
172                 .mode           = 0644,
173                 .proc_handler   = proc_dointvec_minmax,
174                 .extra1         = &sack_timer_min,
175                 .extra2         = &sack_timer_max,
176         },
177         {
178                 .procname       = "hb_interval",
179                 .data           = &init_net.sctp.hb_interval,
180                 .maxlen         = sizeof(unsigned int),
181                 .mode           = 0644,
182                 .proc_handler   = proc_dointvec_minmax,
183                 .extra1         = &one,
184                 .extra2         = &timer_max
185         },
186         {
187                 .procname       = "association_max_retrans",
188                 .data           = &init_net.sctp.max_retrans_association,
189                 .maxlen         = sizeof(int),
190                 .mode           = 0644,
191                 .proc_handler   = proc_dointvec_minmax,
192                 .extra1         = &one,
193                 .extra2         = &int_max
194         },
195         {
196                 .procname       = "path_max_retrans",
197                 .data           = &init_net.sctp.max_retrans_path,
198                 .maxlen         = sizeof(int),
199                 .mode           = 0644,
200                 .proc_handler   = proc_dointvec_minmax,
201                 .extra1         = &one,
202                 .extra2         = &int_max
203         },
204         {
205                 .procname       = "max_init_retransmits",
206                 .data           = &init_net.sctp.max_retrans_init,
207                 .maxlen         = sizeof(int),
208                 .mode           = 0644,
209                 .proc_handler   = proc_dointvec_minmax,
210                 .extra1         = &one,
211                 .extra2         = &int_max
212         },
213         {
214                 .procname       = "pf_retrans",
215                 .data           = &init_net.sctp.pf_retrans,
216                 .maxlen         = sizeof(int),
217                 .mode           = 0644,
218                 .proc_handler   = proc_dointvec_minmax,
219                 .extra1         = &zero,
220                 .extra2         = &int_max
221         },
222         {
223                 .procname       = "sndbuf_policy",
224                 .data           = &init_net.sctp.sndbuf_policy,
225                 .maxlen         = sizeof(int),
226                 .mode           = 0644,
227                 .proc_handler   = proc_dointvec,
228         },
229         {
230                 .procname       = "rcvbuf_policy",
231                 .data           = &init_net.sctp.rcvbuf_policy,
232                 .maxlen         = sizeof(int),
233                 .mode           = 0644,
234                 .proc_handler   = proc_dointvec,
235         },
236         {
237                 .procname       = "default_auto_asconf",
238                 .data           = &init_net.sctp.default_auto_asconf,
239                 .maxlen         = sizeof(int),
240                 .mode           = 0644,
241                 .proc_handler   = proc_dointvec,
242         },
243         {
244                 .procname       = "addip_enable",
245                 .data           = &init_net.sctp.addip_enable,
246                 .maxlen         = sizeof(int),
247                 .mode           = 0644,
248                 .proc_handler   = proc_dointvec,
249         },
250         {
251                 .procname       = "addip_noauth_enable",
252                 .data           = &init_net.sctp.addip_noauth,
253                 .maxlen         = sizeof(int),
254                 .mode           = 0644,
255                 .proc_handler   = proc_dointvec,
256         },
257         {
258                 .procname       = "prsctp_enable",
259                 .data           = &init_net.sctp.prsctp_enable,
260                 .maxlen         = sizeof(int),
261                 .mode           = 0644,
262                 .proc_handler   = proc_dointvec,
263         },
264         {
265                 .procname       = "auth_enable",
266                 .data           = &init_net.sctp.auth_enable,
267                 .maxlen         = sizeof(int),
268                 .mode           = 0644,
269                 .proc_handler   = proc_dointvec,
270         },
271         {
272                 .procname       = "addr_scope_policy",
273                 .data           = &init_net.sctp.scope_policy,
274                 .maxlen         = sizeof(int),
275                 .mode           = 0644,
276                 .proc_handler   = proc_dointvec_minmax,
277                 .extra1         = &zero,
278                 .extra2         = &addr_scope_max,
279         },
280         {
281                 .procname       = "rwnd_update_shift",
282                 .data           = &init_net.sctp.rwnd_upd_shift,
283                 .maxlen         = sizeof(int),
284                 .mode           = 0644,
285                 .proc_handler   = &proc_dointvec_minmax,
286                 .extra1         = &one,
287                 .extra2         = &rwnd_scale_max,
288         },
289         {
290                 .procname       = "max_autoclose",
291                 .data           = &init_net.sctp.max_autoclose,
292                 .maxlen         = sizeof(unsigned long),
293                 .mode           = 0644,
294                 .proc_handler   = &proc_doulongvec_minmax,
295                 .extra1         = &max_autoclose_min,
296                 .extra2         = &max_autoclose_max,
297         },
298 
299         { /* sentinel */ }
300 };
301 
302 static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
303                                 void __user *buffer, size_t *lenp,
304                                 loff_t *ppos)
305 {
306         struct net *net = current->nsproxy->net_ns;
307         char tmp[8];
308         struct ctl_table tbl;
309         int ret;
310         int changed = 0;
311         char *none = "none";
312 
313         memset(&tbl, 0, sizeof(struct ctl_table));
314 
315         if (write) {
316                 tbl.data = tmp;
317                 tbl.maxlen = 8;
318         } else {
319                 tbl.data = net->sctp.sctp_hmac_alg ? : none;
320                 tbl.maxlen = strlen(tbl.data);
321         }
322                 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
323 
324         if (write) {
325 #ifdef CONFIG_CRYPTO_MD5
326                 if (!strncmp(tmp, "md5", 3)) {
327                         net->sctp.sctp_hmac_alg = "md5";
328                         changed = 1;
329                 }
330 #endif
331 #ifdef CONFIG_CRYPTO_SHA1
332                 if (!strncmp(tmp, "sha1", 4)) {
333                         net->sctp.sctp_hmac_alg = "sha1";
334                         changed = 1;
335                 }
336 #endif
337                 if (!strncmp(tmp, "none", 4)) {
338                         net->sctp.sctp_hmac_alg = NULL;
339                         changed = 1;
340                 }
341 
342                 if (!changed)
343                         ret = -EINVAL;
344         }
345 
346         return ret;
347 }
348 
349 static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
350                                 void __user *buffer, size_t *lenp,
351                                 loff_t *ppos)
352 {
353         struct net *net = current->nsproxy->net_ns;
354         int new_value;
355         struct ctl_table tbl;
356         unsigned int min = *(unsigned int *) ctl->extra1;
357         unsigned int max = *(unsigned int *) ctl->extra2;
358         int ret;
359 
360         memset(&tbl, 0, sizeof(struct ctl_table));
361         tbl.maxlen = sizeof(unsigned int);
362 
363         if (write)
364                 tbl.data = &new_value;
365         else
366                 tbl.data = &net->sctp.rto_min;
367         ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
368         if (write) {
369                 if (ret || new_value > max || new_value < min)
370                         return -EINVAL;
371                 net->sctp.rto_min = new_value;
372         }
373         return ret;
374 }
375 
376 static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
377                                 void __user *buffer, size_t *lenp,
378                                 loff_t *ppos)
379 {
380         struct net *net = current->nsproxy->net_ns;
381         int new_value;
382         struct ctl_table tbl;
383         unsigned int min = *(unsigned int *) ctl->extra1;
384         unsigned int max = *(unsigned int *) ctl->extra2;
385         int ret;
386 
387         memset(&tbl, 0, sizeof(struct ctl_table));
388         tbl.maxlen = sizeof(unsigned int);
389 
390         if (write)
391                 tbl.data = &new_value;
392         else
393                 tbl.data = &net->sctp.rto_max;
394         ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
395         if (write) {
396                 if (ret || new_value > max || new_value < min)
397                         return -EINVAL;
398                 net->sctp.rto_max = new_value;
399         }
400         return ret;
401 }
402 
403 int sctp_sysctl_net_register(struct net *net)
404 {
405         struct ctl_table *table;
406         int i;
407 
408         table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
409         if (!table)
410                 return -ENOMEM;
411 
412         for (i = 0; table[i].data; i++)
413                 table[i].data += (char *)(&net->sctp) - (char *)&init_net.sctp;
414 
415         net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
416         return 0;
417 }
418 
419 void sctp_sysctl_net_unregister(struct net *net)
420 {
421         struct ctl_table *table;
422 
423         table = net->sctp.sysctl_header->ctl_table_arg;
424         unregister_net_sysctl_table(net->sctp.sysctl_header);
425         kfree(table);
426 }
427 
428 static struct ctl_table_header * sctp_sysctl_header;
429 
430 /* Sysctl registration.  */
431 void sctp_sysctl_register(void)
432 {
433         sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
434 }
435 
436 /* Sysctl deregistration.  */
437 void sctp_sysctl_unregister(void)
438 {
439         unregister_net_sysctl_table(sctp_sysctl_header);
440 }
441 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp