2 * DECnet An implementation of the DECnet protocol suite for the LINUX
3 * operating system. DECnet is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * DECnet sysctl support functions
8 * Author: Steve Whitehouse <SteveW@ACM.org>
12 * Steve Whitehouse - C99 changes and default device handling
13 * Steve Whitehouse - Memory buffer settings, like the tcp ones
17 #include <linux/sysctl.h>
19 #include <linux/netdevice.h>
20 #include <linux/string.h>
21 #include <net/neighbour.h>
25 #include <asm/uaccess.h>
28 #include <net/dn_dev.h>
29 #include <net/dn_route.h>
32 int decnet_debug_level;
33 int decnet_time_wait = 30;
34 int decnet_dn_count = 1;
35 int decnet_di_count = 3;
36 int decnet_dr_count = 3;
37 int decnet_log_martians = 1;
38 int decnet_no_fc_max_cwnd = NSP_MIN_WINDOW;
40 /* Reasonable defaults, I hope, based on tcp's defaults */
41 int sysctl_decnet_mem[3] = { 768 << 3, 1024 << 3, 1536 << 3 };
42 int sysctl_decnet_wmem[3] = { 4 * 1024, 16 * 1024, 128 * 1024 };
43 int sysctl_decnet_rmem[3] = { 4 * 1024, 87380, 87380 * 2 };
46 extern int decnet_dst_gc_interval;
47 static int min_decnet_time_wait[] = { 5 };
48 static int max_decnet_time_wait[] = { 600 };
49 static int min_state_count[] = { 1 };
50 static int max_state_count[] = { NSP_MAXRXTSHIFT };
51 static int min_decnet_dst_gc_interval[] = { 1 };
52 static int max_decnet_dst_gc_interval[] = { 60 };
53 static int min_decnet_no_fc_max_cwnd[] = { NSP_MIN_WINDOW };
54 static int max_decnet_no_fc_max_cwnd[] = { NSP_MAX_WINDOW };
55 static char node_name[7] = "???";
57 static struct ctl_table_header *dn_table_header = NULL;
62 #define ISNUM(x) (((x) >= '0') && ((x) <= '9'))
63 #define ISLOWER(x) (((x) >= 'a') && ((x) <= 'z'))
64 #define ISUPPER(x) (((x) >= 'A') && ((x) <= 'Z'))
65 #define ISALPHA(x) (ISLOWER(x) || ISUPPER(x))
66 #define INVALID_END_CHAR(x) (ISNUM(x) || ISALPHA(x))
68 static void strip_it(char *str)
85 * Simple routine to parse an ascii DECnet address
86 * into a network order address.
88 static int parse_addr(__le16 *addr, char *str)
92 while(*str && !ISNUM(*str)) str++;
97 area = (*str++ - '0');
100 area += (*str++ - '0');
112 node += (*str++ - '0');
116 node += (*str++ - '0');
120 node += (*str++ - '0');
123 if ((node > 1023) || (area > 63))
126 if (INVALID_END_CHAR(*str))
129 *addr = cpu_to_le16((area << 10) | node);
135 static int dn_node_address_strategy(ctl_table *table,
136 void __user *oldval, size_t __user *oldlenp,
137 void __user *newval, size_t newlen)
142 if (oldval && oldlenp) {
143 if (get_user(len, oldlenp))
146 if (len != sizeof(unsigned short))
148 if (put_user(decnet_address, (__le16 __user *)oldval))
152 if (newval && newlen) {
153 if (newlen != sizeof(unsigned short))
155 if (get_user(addr, (__le16 __user *)newval))
158 dn_dev_devices_off();
160 decnet_address = addr;
167 static int dn_node_address_handler(ctl_table *table, int write,
169 size_t *lenp, loff_t *ppos)
171 char addr[DN_ASCBUF_LEN];
175 if (!*lenp || (*ppos && !write)) {
181 len = (*lenp < DN_ASCBUF_LEN) ? *lenp : (DN_ASCBUF_LEN-1);
183 if (copy_from_user(addr, buffer, len))
189 if (parse_addr(&dnaddr, addr))
192 dn_dev_devices_off();
194 decnet_address = dnaddr;
203 dn_addr2asc(le16_to_cpu(decnet_address), addr);
207 if (len > *lenp) len = *lenp;
209 if (copy_to_user(buffer, addr, len))
219 static int dn_def_dev_strategy(ctl_table *table,
220 void __user *oldval, size_t __user *oldlenp,
221 void __user *newval, size_t newlen)
224 struct net_device *dev;
231 if (oldval && oldlenp) {
232 if (get_user(len, oldlenp))
235 dev = dn_dev_get_default();
237 strcpy(devname, dev->name);
241 namel = strlen(devname) + 1;
242 if (len > namel) len = namel;
244 if (copy_to_user(oldval, devname, len))
247 if (put_user(len, oldlenp))
252 if (newval && newlen) {
256 if (copy_from_user(devname, newval, newlen))
261 dev = dev_get_by_name(&init_net, devname);
266 if (dev->dn_ptr != NULL) {
267 rv = dn_dev_set_default(dev, 1);
277 static int dn_def_dev_handler(ctl_table *table, int write,
279 size_t *lenp, loff_t *ppos)
282 struct net_device *dev;
285 if (!*lenp || (*ppos && !write)) {
294 if (copy_from_user(devname, buffer, *lenp))
300 dev = dev_get_by_name(&init_net, devname);
304 if (dev->dn_ptr == NULL) {
309 if (dn_dev_set_default(dev, 1)) {
318 dev = dn_dev_get_default();
324 strcpy(devname, dev->name);
326 len = strlen(devname);
327 devname[len++] = '\n';
329 if (len > *lenp) len = *lenp;
331 if (copy_to_user(buffer, devname, len))
340 static ctl_table dn_table[] = {
342 .ctl_name = NET_DECNET_NODE_ADDRESS,
343 .procname = "node_address",
346 .proc_handler = dn_node_address_handler,
347 .strategy = dn_node_address_strategy,
350 .ctl_name = NET_DECNET_NODE_NAME,
351 .procname = "node_name",
355 .proc_handler = proc_dostring,
356 .strategy = sysctl_string,
359 .ctl_name = NET_DECNET_DEFAULT_DEVICE,
360 .procname = "default_device",
363 .proc_handler = dn_def_dev_handler,
364 .strategy = dn_def_dev_strategy,
367 .ctl_name = NET_DECNET_TIME_WAIT,
368 .procname = "time_wait",
369 .data = &decnet_time_wait,
370 .maxlen = sizeof(int),
372 .proc_handler = proc_dointvec_minmax,
373 .strategy = sysctl_intvec,
374 .extra1 = &min_decnet_time_wait,
375 .extra2 = &max_decnet_time_wait
378 .ctl_name = NET_DECNET_DN_COUNT,
379 .procname = "dn_count",
380 .data = &decnet_dn_count,
381 .maxlen = sizeof(int),
383 .proc_handler = proc_dointvec_minmax,
384 .strategy = sysctl_intvec,
385 .extra1 = &min_state_count,
386 .extra2 = &max_state_count
389 .ctl_name = NET_DECNET_DI_COUNT,
390 .procname = "di_count",
391 .data = &decnet_di_count,
392 .maxlen = sizeof(int),
394 .proc_handler = proc_dointvec_minmax,
395 .strategy = sysctl_intvec,
396 .extra1 = &min_state_count,
397 .extra2 = &max_state_count
400 .ctl_name = NET_DECNET_DR_COUNT,
401 .procname = "dr_count",
402 .data = &decnet_dr_count,
403 .maxlen = sizeof(int),
405 .proc_handler = proc_dointvec_minmax,
406 .strategy = sysctl_intvec,
407 .extra1 = &min_state_count,
408 .extra2 = &max_state_count
411 .ctl_name = NET_DECNET_DST_GC_INTERVAL,
412 .procname = "dst_gc_interval",
413 .data = &decnet_dst_gc_interval,
414 .maxlen = sizeof(int),
416 .proc_handler = proc_dointvec_minmax,
417 .strategy = sysctl_intvec,
418 .extra1 = &min_decnet_dst_gc_interval,
419 .extra2 = &max_decnet_dst_gc_interval
422 .ctl_name = NET_DECNET_NO_FC_MAX_CWND,
423 .procname = "no_fc_max_cwnd",
424 .data = &decnet_no_fc_max_cwnd,
425 .maxlen = sizeof(int),
427 .proc_handler = proc_dointvec_minmax,
428 .strategy = sysctl_intvec,
429 .extra1 = &min_decnet_no_fc_max_cwnd,
430 .extra2 = &max_decnet_no_fc_max_cwnd
433 .ctl_name = NET_DECNET_MEM,
434 .procname = "decnet_mem",
435 .data = &sysctl_decnet_mem,
436 .maxlen = sizeof(sysctl_decnet_mem),
438 .proc_handler = proc_dointvec,
439 .strategy = sysctl_intvec,
442 .ctl_name = NET_DECNET_RMEM,
443 .procname = "decnet_rmem",
444 .data = &sysctl_decnet_rmem,
445 .maxlen = sizeof(sysctl_decnet_rmem),
447 .proc_handler = proc_dointvec,
448 .strategy = sysctl_intvec,
451 .ctl_name = NET_DECNET_WMEM,
452 .procname = "decnet_wmem",
453 .data = &sysctl_decnet_wmem,
454 .maxlen = sizeof(sysctl_decnet_wmem),
456 .proc_handler = proc_dointvec,
457 .strategy = sysctl_intvec,
460 .ctl_name = NET_DECNET_DEBUG_LEVEL,
462 .data = &decnet_debug_level,
463 .maxlen = sizeof(int),
465 .proc_handler = proc_dointvec,
466 .strategy = sysctl_intvec,
471 static struct ctl_path dn_path[] = {
472 { .procname = "net", .ctl_name = CTL_NET, },
473 { .procname = "decnet", .ctl_name = NET_DECNET, },
477 void dn_register_sysctl(void)
479 dn_table_header = register_sysctl_paths(dn_path, dn_table);
482 void dn_unregister_sysctl(void)
484 unregister_sysctl_table(dn_table_header);
487 #else /* CONFIG_SYSCTL */
488 void dn_unregister_sysctl(void)
491 void dn_register_sysctl(void)