kernel/sysctl.c

   1 /*
   2  * sysctl.c: General linux system control interface
   3  *
   4  * Begun 24 March 1995, Stephen Tweedie
   5  * Added /proc support, Dec 1995
   6  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
   7  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
   8  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
   9  * Dynamic registration fixes, Stephen Tweedie.
  10  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
  11  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris Horn.
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/malloc.h>
  16 #include <linux/sysctl.h>
  17 #include <linux/swapctl.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/ctype.h>
  20 #include <linux/utsname.h>
  21 #include <linux/swapctl.h>
  22 #include <linux/smp_lock.h>
  23 #include <linux/init.h>
  24
  25 #include <asm/uaccess.h>
  26
  27 #ifdef CONFIG_ROOT_NFS
  28 #include <linux/nfs_fs.h>
  29 #endif
  30
  31 #if defined(CONFIG_SYSCTL)
  32
  33 /* External variables not in a header file. */
  34 extern int panic_timeout;
  35 extern int console_loglevel, C_A_D;
  36 extern int bdf_prm[], bdflush_min[], bdflush_max[];
  37 extern char binfmt_java_interpreter[], binfmt_java_appletviewer[];
  38 extern int sysctl_overcommit_memory;
  39 extern int nr_queued_signals, max_queued_signals;
  40
  41 #ifdef CONFIG_KMOD
  42 extern char modprobe_path[];
  43 #endif
  44 #ifdef CONFIG_CHR_DEV_SG
  45 extern int sg_big_buff;
  46 #endif
  47 #ifdef CONFIG_SYSVIPC
  48 extern int shmmax;
  49 #endif
  50
  51 #ifdef __sparc__
  52 extern char reboot_command [];
  53 #endif
  54 #ifdef __powerpc__
  55 extern unsigned long htab_reclaim_on, zero_paged_on, powersave_nap;
  56 int proc_dol2crvec(ctl_table *table, int write, struct file *filp,
  57                   void *buffer, size_t *lenp);
  58 #endif
  59
  60 #ifdef CONFIG_BSD_PROCESS_ACCT
  61 extern int acct_parm[];
  62 #endif
  63
  64 extern int pgt_cache_water[];
  65
  66 static int parse_table(int *, int, void *, size_t *, void *, size_t,
  67                        ctl_table *, void **);
  68 static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
  69                   void *buffer, size_t *lenp);
  70
  71
  72 static ctl_table root_table[];
  73 static struct ctl_table_header root_table_header =
  74         {root_table, DNODE_SINGLE(&root_table_header)};
  75
  76 static ctl_table kern_table[];
  77 static ctl_table vm_table[];
  78 #ifdef CONFIG_NET
  79 extern ctl_table net_table[];
  80 #endif
  81 static ctl_table proc_table[];
  82 static ctl_table fs_table[];
  83 static ctl_table debug_table[];
  84 static ctl_table dev_table[];
  85
  86
  87 /* /proc declarations: */
  88
  89 #ifdef CONFIG_PROC_FS
  90
  91 static ssize_t proc_readsys(struct file *, char *, size_t, loff_t *);
  92 static ssize_t proc_writesys(struct file *, const char *, size_t, loff_t *);
  93 static int proc_sys_permission(struct inode *, int);
  94
  95 struct file_operations proc_sys_file_operations =
  96 {
  97         NULL,           /* lseek   */
  98         proc_readsys,   /* read    */
  99         proc_writesys,  /* write   */
 100         NULL,           /* readdir */
 101         NULL,           /* poll    */
 102         NULL,           /* ioctl   */
 103         NULL,           /* mmap    */
 104         NULL,           /* no special open code    */
 105         NULL,           /* no special flush code */
 106         NULL,           /* no special release code */
 107         NULL            /* can't fsync */
 108 };
 109
 110 struct inode_operations proc_sys_inode_operations =
 111 {
 112         &proc_sys_file_operations,
 113         NULL,           /* create */
 114         NULL,           /* lookup */
 115         NULL,           /* link */
 116         NULL,           /* unlink */
 117         NULL,           /* symlink */
 118         NULL,           /* mkdir */
 119         NULL,           /* rmdir */
 120         NULL,           /* mknod */
 121         NULL,           /* rename */
 122         NULL,           /* readlink */
 123         NULL,           /* follow_link */
 124         NULL,           /* readpage */
 125         NULL,           /* writepage */
 126         NULL,           /* bmap */
 127         NULL,           /* truncate */
 128         proc_sys_permission
 129 };
 130
 131 extern struct proc_dir_entry proc_sys_root;
 132
 133 static void register_proc_table(ctl_table *, struct proc_dir_entry *);
 134 static void unregister_proc_table(ctl_table *, struct proc_dir_entry *);
 135 #endif
 136 extern int inodes_stat[];
 137 extern int dentry_stat[];
 138
 139 /* The default sysctl tables: */
 140
 141 static ctl_table root_table[] = {
 142         {CTL_KERN, "kernel", NULL, 0, 0555, kern_table},
 143         {CTL_VM, "vm", NULL, 0, 0555, vm_table},
 144 #ifdef CONFIG_NET
 145         {CTL_NET, "net", NULL, 0, 0555, net_table},
 146 #endif
 147         {CTL_PROC, "proc", NULL, 0, 0555, proc_table},
 148         {CTL_FS, "fs", NULL, 0, 0555, fs_table},
 149         {CTL_DEBUG, "debug", NULL, 0, 0555, debug_table},
 150         {CTL_DEV, "dev", NULL, 0, 0555, dev_table},
 151         {0}
 152 };
 153
 154 static ctl_table kern_table[] = {
 155         {KERN_OSTYPE, "ostype", system_utsname.sysname, 64,
 156          0444, NULL, &proc_doutsstring, &sysctl_string},
 157         {KERN_OSRELEASE, "osrelease", system_utsname.release, 64,
 158          0444, NULL, &proc_doutsstring, &sysctl_string},
 159         {KERN_VERSION, "version", system_utsname.version, 64,
 160          0444, NULL, &proc_doutsstring, &sysctl_string},
 161         {KERN_NODENAME, "hostname", system_utsname.nodename, 64,
 162          0644, NULL, &proc_doutsstring, &sysctl_string},
 163         {KERN_DOMAINNAME, "domainname", system_utsname.domainname, 64,
 164          0644, NULL, &proc_doutsstring, &sysctl_string},
 165         {KERN_PANIC, "panic", &panic_timeout, sizeof(int),
 166          0644, NULL, &proc_dointvec},
 167 #ifdef CONFIG_BLK_DEV_INITRD
 168         {KERN_REALROOTDEV, "real-root-dev", &real_root_dev, sizeof(int),
 169          0644, NULL, &proc_dointvec},
 170 #endif
 171 #ifdef CONFIG_BINFMT_JAVA
 172         {KERN_JAVA_INTERPRETER, "java-interpreter", binfmt_java_interpreter,
 173          64, 0644, NULL, &proc_dostring, &sysctl_string },
 174         {KERN_JAVA_APPLETVIEWER, "java-appletviewer", binfmt_java_appletviewer,
 175          64, 0644, NULL, &proc_dostring, &sysctl_string },
 176 #endif
 177 #ifdef __sparc__
 178         {KERN_SPARC_REBOOT, "reboot-cmd", reboot_command,
 179          256, 0644, NULL, &proc_dostring, &sysctl_string },
 180 #endif
 181 #ifdef __powerpc__
 182         {KERN_PPC_HTABRECLAIM, "htab-reclaim", &htab_reclaim_on, sizeof(int),
 183          0644, NULL, &proc_dointvec},
 184         {KERN_PPC_ZEROPAGED, "zero-paged", &zero_paged_on, sizeof(int),
 185          0644, NULL, &proc_dointvec},
 186         {KERN_PPC_POWERSAVE_NAP, "powersave-nap", &powersave_nap, sizeof(int),
 187          0644, NULL, &proc_dointvec},
 188         {KERN_PPC_L2CR, "l2cr", NULL, 0,
 189          0644, NULL, &proc_dol2crvec},
 190 #endif
 191         {KERN_CTLALTDEL, "ctrl-alt-del", &C_A_D, sizeof(int),
 192          0644, NULL, &proc_dointvec},
 193         {KERN_PRINTK, "printk", &console_loglevel, 4*sizeof(int),
 194          0644, NULL, &proc_dointvec},
 195 #ifdef CONFIG_KMOD
 196         {KERN_MODPROBE, "modprobe", &modprobe_path, 256,
 197          0644, NULL, &proc_dostring, &sysctl_string },
 198 #endif
 199 #ifdef CONFIG_CHR_DEV_SG
 200         {KERN_SG_BIG_BUFF, "sg-big-buff", &sg_big_buff, sizeof (int),
 201          0444, NULL, &proc_dointvec},
 202 #endif
 203 #ifdef CONFIG_BSD_PROCESS_ACCT
 204         {KERN_ACCT, "acct", &acct_parm, 3*sizeof(int),
 205         0644, NULL, &proc_dointvec},
 206 #endif
 207         {KERN_RTSIGNR, "rtsig-nr", &nr_queued_signals, sizeof(int),
 208          0444, NULL, &proc_dointvec},
 209         {KERN_RTSIGMAX, "rtsig-max", &max_queued_signals, sizeof(int),
 210          0644, NULL, &proc_dointvec},
 211 #ifdef CONFIG_SYSVIPC
 212         {KERN_SHMMAX, "shmmax", &shmmax, sizeof (int),
 213          0644, NULL, &proc_dointvec},
 214 #endif
 215         {0}
 216 };
 217
 218 static ctl_table vm_table[] = {
 219         {VM_FREEPG, "freepages",
 220          &freepages, sizeof(freepages_t), 0644, NULL, &proc_dointvec},
 221         {VM_BDFLUSH, "bdflush", &bdf_prm, 9*sizeof(int), 0600, NULL,
 222          &proc_dointvec_minmax, &sysctl_intvec, NULL,
 223          &bdflush_min, &bdflush_max},
 224         {VM_OVERCOMMIT_MEMORY, "overcommit_memory", &sysctl_overcommit_memory,
 225          sizeof(sysctl_overcommit_memory), 0644, NULL, &proc_dointvec},
 226         {VM_BUFFERMEM, "buffermem",
 227          &buffer_mem, sizeof(buffer_mem_t), 0644, NULL, &proc_dointvec},
 228         {VM_PAGECACHE, "pagecache",
 229          &page_cache, sizeof(buffer_mem_t), 0644, NULL, &proc_dointvec},
 230         {VM_PAGERDAEMON, "kswapd",
 231          &pager_daemon, sizeof(pager_daemon_t), 0644, NULL, &proc_dointvec},
 232         {VM_PGT_CACHE, "pagetable_cache",
 233          &pgt_cache_water, 2*sizeof(int), 0600, NULL, &proc_dointvec},
 234         {VM_PAGE_CLUSTER, "page-cluster",
 235          &page_cluster, sizeof(int), 0600, NULL, &proc_dointvec},
 236         {0}
 237 };
 238
 239 static ctl_table proc_table[] = {
 240         {0}
 241 };
 242
 243 static ctl_table fs_table[] = {
 244         {FS_NRINODE, "inode-nr", &inodes_stat, 2*sizeof(int),
 245          0444, NULL, &proc_dointvec},
 246         {FS_STATINODE, "inode-state", &inodes_stat, 7*sizeof(int),
 247          0444, NULL, &proc_dointvec},
 248         {FS_MAXINODE, "inode-max", &max_inodes, sizeof(int),
 249          0644, NULL, &proc_dointvec},
 250         {FS_NRFILE, "file-nr", &nr_files, 3*sizeof(int),
 251          0444, NULL, &proc_dointvec},
 252         {FS_MAXFILE, "file-max", &max_files, sizeof(int),
 253          0644, NULL, &proc_dointvec},
 254         {FS_NRSUPER, "super-nr", &nr_super_blocks, sizeof(int),
 255          0444, NULL, &proc_dointvec},
 256         {FS_MAXSUPER, "super-max", &max_super_blocks, sizeof(int),
 257          0644, NULL, &proc_dointvec},
 258         {FS_NRDQUOT, "dquot-nr", &nr_dquots, 2*sizeof(int),
 259          0444, NULL, &proc_dointvec},
 260         {FS_MAXDQUOT, "dquot-max", &max_dquots, sizeof(int),
 261          0644, NULL, &proc_dointvec},
 262         {FS_DENTRY, "dentry-state", &dentry_stat, 6*sizeof(int),
 263          0444, NULL, &proc_dointvec},
 264         {0}
 265 };
 266
 267 static ctl_table debug_table[] = {
 268         {0}
 269 };
 270
 271 static ctl_table dev_table[] = {
 272         {0}
 273 };
 274
 275
 276 void __init sysctl_init(void)
 277 {
 278 #ifdef CONFIG_PROC_FS
 279         register_proc_table(root_table, &proc_sys_root);
 280 #endif
 281 }
 282
 283
 284 int do_sysctl (int *name, int nlen,
 285                void *oldval, size_t *oldlenp,
 286                void *newval, size_t newlen)
 287 {
 288         int error;
 289         struct ctl_table_header *tmp;
 290         void *context;
 291
 292         if (nlen == 0 || nlen >= CTL_MAXNAME)
 293                 return -ENOTDIR;
 294
 295         if (oldval)
 296         {
 297                 int old_len;
 298                 if (!oldlenp)
 299                         return -EFAULT;
 300                 if(get_user(old_len, oldlenp))
 301                         return -EFAULT;
 302         }
 303         tmp = &root_table_header;
 304         do {
 305                 context = NULL;
 306                 error = parse_table(name, nlen, oldval, oldlenp,
 307                                     newval, newlen, tmp->ctl_table, &context);
 308                 if (context)
 309                         kfree(context);
 310                 if (error != -ENOTDIR)
 311                         return error;
 312                 tmp = tmp->DLIST_NEXT(ctl_entry);
 313         } while (tmp != &root_table_header);
 314         return -ENOTDIR;
 315 }
 316
 317 extern asmlinkage int sys_sysctl(struct __sysctl_args *args)
 318 {
 319         struct __sysctl_args tmp;
 320         int error;
 321
 322         if(copy_from_user(&tmp, args, sizeof(tmp)))
 323                 return -EFAULT;
 324
 325         lock_kernel();
 326         error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
 327                           tmp.newval, tmp.newlen);
 328         unlock_kernel();
 329         return error;
 330 }
 331
 332 /* Like in_group_p, but testing against egid, not fsgid */
 333 static int in_egroup_p(gid_t grp)
 334 {
 335         if (grp != current->egid) {
 336                 int i = current->ngroups;
 337                 if (i) {
 338                         gid_t *groups = current->groups;
 339                         do {
 340                                 if (*groups == grp)
 341                                         goto out;
 342                                 groups++;
 343                                 i--;
 344                         } while (i);
 345                 }
 346                 return 0;
 347         }
 348 out:
 349         return 1;
 350 }
 351
 352 /* ctl_perm does NOT grant the superuser all rights automatically, because
 353    some sysctl variables are readonly even to root. */
 354
 355 static int test_perm(int mode, int op)
 356 {
 357         if (!current->euid)
 358                 mode >>= 6;
 359         else if (in_egroup_p(0))
 360                 mode >>= 3;
 361         if ((mode & op & 0007) == op)
 362                 return 0;
 363         return -EACCES;
 364 }
 365
 366 static inline int ctl_perm(ctl_table *table, int op)
 367 {
 368         return test_perm(table->mode, op);
 369 }
 370
 371 static int parse_table(int *name, int nlen,
 372                        void *oldval, size_t *oldlenp,
 373                        void *newval, size_t newlen,
 374                        ctl_table *table, void **context)
 375 {
 376         int error;
 377 repeat:
 378         if (!nlen)
 379                 return -ENOTDIR;
 380
 381         for ( ; table->ctl_name; table++) {
 382                 int n;
 383                 if(get_user(n,name))
 384                         return -EFAULT;
 385                 if (n == table->ctl_name ||
 386                     table->ctl_name == CTL_ANY) {
 387                         if (table->child) {
 388                                 if (ctl_perm(table, 001))
 389                                         return -EPERM;
 390                                 if (table->strategy) {
 391                                         error = table->strategy(
 392                                                 table, name, nlen,
 393                                                 oldval, oldlenp,
 394                                                 newval, newlen, context);
 395                                 if (error)
 396                                         return error;
 397                                 }
 398                                 name++;
 399                                 nlen--;
 400                                 table = table->child;
 401                                 goto repeat;
 402                         }
 403                         error = do_sysctl_strategy(table, name, nlen,
 404                                                    oldval, oldlenp,
 405                                                    newval, newlen, context);
 406                         return error;
 407                 }
 408         };
 409         return -ENOTDIR;
 410 }
 411
 412 /* Perform the actual read/write of a sysctl table entry. */
 413 int do_sysctl_strategy (ctl_table *table,
 414                         int *name, int nlen,
 415                         void *oldval, size_t *oldlenp,
 416                         void *newval, size_t newlen, void **context)
 417 {
 418         int op = 0, rc, len;
 419
 420         if (oldval)
 421                 op |= 004;
 422         if (newval)
 423                 op |= 002;
 424         if (ctl_perm(table, op))
 425                 return -EPERM;
 426
 427         if (table->strategy) {
 428                 rc = table->strategy(table, name, nlen, oldval, oldlenp,
 429                                      newval, newlen, context);
 430                 if (rc < 0)
 431                         return rc;
 432                 if (rc > 0)
 433                         return 0;
 434         }
 435
 436         /* If there is no strategy routine, or if the strategy returns
 437          * zero, proceed with automatic r/w */
 438         if (table->data && table->maxlen) {
 439                 if (oldval && oldlenp) {
 440                         get_user(len, oldlenp);
 441                         if (len) {
 442                                 if (len > table->maxlen)
 443                                         len = table->maxlen;
 444                                 if(copy_to_user(oldval, table->data, len))
 445                                         return -EFAULT;
 446                                 if(put_user(len, oldlenp))
 447                                         return -EFAULT;
 448                         }
 449                 }
 450                 if (newval && newlen) {
 451                         len = newlen;
 452                         if (len > table->maxlen)
 453                                 len = table->maxlen;
 454                         if(copy_from_user(table->data, newval, len))
 455                                 return -EFAULT;
 456                 }
 457         }
 458         return 0;
 459 }
 460
 461 struct ctl_table_header *register_sysctl_table(ctl_table * table,
 462                                                int insert_at_head)
 463 {
 464         struct ctl_table_header *tmp;
 465         tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
 466         if (!tmp)
 467                 return 0;
 468         *tmp = ((struct ctl_table_header) {table, DNODE_NULL});
 469         if (insert_at_head)
 470                 DLIST_INSERT_AFTER(&root_table_header, tmp, ctl_entry);
 471         else
 472                 DLIST_INSERT_BEFORE(&root_table_header, tmp, ctl_entry);
 473 #ifdef CONFIG_PROC_FS
 474         register_proc_table(table, &proc_sys_root);
 475 #endif
 476         return tmp;
 477 }
 478
 479 /*
 480  * Unlink and free a ctl_table.
 481  */
 482 void unregister_sysctl_table(struct ctl_table_header * header)
 483 {
 484         DLIST_DELETE(header, ctl_entry);
 485 #ifdef CONFIG_PROC_FS
 486         unregister_proc_table(header->ctl_table, &proc_sys_root);
 487 #endif
 488         kfree(header);
 489 }
 490
 491 /*
 492  * /proc/sys support
 493  */
 494
 495 #ifdef CONFIG_PROC_FS
 496
 497 /* Scan the sysctl entries in table and add them all into /proc */
 498 static void register_proc_table(ctl_table * table, struct proc_dir_entry *root)
 499 {
 500         struct proc_dir_entry *de;
 501         int len;
 502         mode_t mode;
 503
 504         for (; table->ctl_name; table++) {
 505                 /* Can't do anything without a proc name. */
 506                 if (!table->procname)
 507                         continue;
 508                 /* Maybe we can't do anything with it... */
 509                 if (!table->proc_handler && !table->child) {
 510                         printk(KERN_WARNING "SYSCTL: Can't register %s\n",
 511                                 table->procname);
 512                         continue;
 513                 }
 514
 515                 len = strlen(table->procname);
 516                 mode = table->mode;
 517
 518                 de = NULL;
 519                 if (table->proc_handler)
 520                         mode |= S_IFREG;
 521                 else {
 522                         mode |= S_IFDIR;
 523                         for (de = root->subdir; de; de = de->next) {
 524                                 if (proc_match(len, table->procname, de))
 525                                         break;
 526                         }
 527                         /* If the subdir exists already, de is non-NULL */
 528                 }
 529
 530                 if (!de) {
 531                         de = create_proc_entry(table->procname, mode, root);
 532                         if (!de)
 533                                 continue;
 534                         de->data = (void *) table;
 535                         if (table->proc_handler)
 536                                 de->ops = &proc_sys_inode_operations;
 537
 538                 }
 539                 table->de = de;
 540                 if (de->mode & S_IFDIR)
 541                         register_proc_table(table->child, de);
 542         }
 543 }
 544
 545 /*
 546  * Unregister a /proc sysctl table and any subdirectories.
 547  */
 548 static void unregister_proc_table(ctl_table * table, struct proc_dir_entry *root)
 549 {
 550         struct proc_dir_entry *de;
 551         for (; table->ctl_name; table++) {
 552                 if (!(de = table->de))
 553                         continue;
 554                 if (de->mode & S_IFDIR) {
 555                         if (!table->child) {
 556                                 printk (KERN_ALERT "Help - malformed sysctl tree on free\n");
 557                                 continue;
 558                         }
 559                         unregister_proc_table(table->child, de);
 560
 561                         /* Don't unregister directories which still have entries.. */
 562                         if (de->subdir)
 563                                 continue;
 564                 }
 565
 566                 /* Don't unregoster proc entries that are still being used.. */
 567                 if (de->count)
 568                         continue;
 569
 570                 proc_unregister(root, de->low_ino);
 571                 table->de = NULL;
 572                 kfree(de);
 573         }
 574 }
 575
 576 static ssize_t do_rw_proc(int write, struct file * file, char * buf,
 577                           size_t count, loff_t *ppos)
 578 {
 579         int op;
 580         struct proc_dir_entry *de;
 581         struct ctl_table *table;
 582         size_t res;
 583         ssize_t error;
 584
 585         de = (struct proc_dir_entry*) file->f_dentry->d_inode->u.generic_ip;
 586         if (!de || !de->data)
 587                 return -ENOTDIR;
 588         table = (struct ctl_table *) de->data;
 589         if (!table || !table->proc_handler)
 590                 return -ENOTDIR;
 591         op = (write ? 002 : 004);
 592         if (ctl_perm(table, op))
 593                 return -EPERM;
 594
 595         res = count;
 596
 597         /*
 598          * FIXME: we need to pass on ppos to the handler.
 599          */
 600
 601         error = (*table->proc_handler) (table, write, file, buf, &res);
 602         if (error)
 603                 return error;
 604         return res;
 605 }
 606
 607 static ssize_t proc_readsys(struct file * file, char * buf,
 608                             size_t count, loff_t *ppos)
 609 {
 610         return do_rw_proc(0, file, buf, count, ppos);
 611 }
 612
 613 static ssize_t proc_writesys(struct file * file, const char * buf,
 614                              size_t count, loff_t *ppos)
 615 {
 616         return do_rw_proc(1, file, (char *) buf, count, ppos);
 617 }
 618
 619 static int proc_sys_permission(struct inode *inode, int op)
 620 {
 621         return test_perm(inode->i_mode, op);
 622 }
 623
 624 int proc_dostring(ctl_table *table, int write, struct file *filp,
 625                   void *buffer, size_t *lenp)
 626 {
 627         int len;
 628         char *p, c;
 629
 630         if (!table->data || !table->maxlen || !*lenp ||
 631             (filp->f_pos && !write)) {
 632                 *lenp = 0;
 633                 return 0;
 634         }
 635
 636         if (write) {
 637                 len = 0;
 638                 p = buffer;
 639                 while (len < *lenp) {
 640                         if(get_user(c, p++))
 641                                 return -EFAULT;
 642                         if (c == 0 || c == '\n')
 643                                 break;
 644                         len++;
 645                 }
 646                 if (len >= table->maxlen)
 647                         len = table->maxlen-1;
 648                 if(copy_from_user(table->data, buffer, len))
 649                         return -EFAULT;
 650                 ((char *) table->data)[len] = 0;
 651                 filp->f_pos += *lenp;
 652         } else {
 653                 len = strlen(table->data);
 654                 if (len > table->maxlen)
 655                         len = table->maxlen;
 656                 if (len > *lenp)
 657                         len = *lenp;
 658                 if (len)
 659                         if(copy_to_user(buffer, table->data, len))
 660                                 return -EFAULT;
 661                 if (len < *lenp) {
 662                         if(put_user('\n', ((char *) buffer) + len))
 663                                 return -EFAULT;
 664                         len++;
 665                 }
 666                 *lenp = len;
 667                 filp->f_pos += len;
 668         }
 669         return 0;
 670 }
 671
 672 /*
 673  *      Special case of dostring for the UTS structure. This has locks
 674  *      to observe. Should this be in kernel/sys.c ????
 675  */
 676
 677 static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
 678                   void *buffer, size_t *lenp)
 679 {
 680         int r;
 681         down(&uts_sem);
 682         r=proc_dostring(table,write,filp,buffer,lenp);
 683         up(&uts_sem);
 684         return r;
 685 }
 686
 687 static int do_proc_dointvec(ctl_table *table, int write, struct file *filp,
 688                   void *buffer, size_t *lenp, int conv)
 689 {
 690         int *i, vleft, first=1, len, left, neg, val;
 691         #define TMPBUFLEN 20
 692         char buf[TMPBUFLEN], *p;
 693
 694         if (!table->data || !table->maxlen || !*lenp ||
 695             (filp->f_pos && !write)) {
 696                 *lenp = 0;
 697                 return 0;
 698         }
 699
 700         i = (int *) table->data;
 701         vleft = table->maxlen / sizeof(int);
 702         left = *lenp;
 703
 704         for (; left && vleft--; i++, first=0) {
 705                 if (write) {
 706                         while (left) {
 707                                 char c;
 708                                 if(get_user(c,(char *) buffer))
 709                                         return -EFAULT;
 710                                 if (!isspace(c))
 711                                         break;
 712                                 left--;
 713                                 ((char *) buffer)++;
 714                         }
 715                         if (!left)
 716                                 break;
 717                         neg = 0;
 718                         len = left;
 719                         if (len > TMPBUFLEN-1)
 720                                 len = TMPBUFLEN-1;
 721                         if(copy_from_user(buf, buffer, len))
 722                                 return -EFAULT;
 723                         buf[len] = 0;
 724                         p = buf;
 725                         if (*p == '-' && left > 1) {
 726                                 neg = 1;
 727                                 left--, p++;
 728                         }
 729                         if (*p < '0' || *p > '9')
 730                                 break;
 731                         val = simple_strtoul(p, &p, 0) * conv;
 732                         len = p-buf;
 733                         if ((len < left) && *p && !isspace(*p))
 734                                 break;
 735                         if (neg)
 736                                 val = -val;
 737                         buffer += len;
 738                         left -= len;
 739                         *i = val;
 740                 } else {
 741                         p = buf;
 742                         if (!first)
 743                                 *p++ = '\t';
 744                         sprintf(p, "%d", (*i) / conv);
 745                         len = strlen(buf);
 746                         if (len > left)
 747                                 len = left;
 748                         if(copy_to_user(buffer, buf, len))
 749                                 return -EFAULT;
 750                         left -= len;
 751                         buffer += len;
 752                 }
 753         }
 754
 755         if (!write && !first && left) {
 756                 if(put_user('\n', (char *) buffer))
 757                         return -EFAULT;
 758                 left--, buffer++;
 759         }
 760         if (write) {
 761                 p = (char *) buffer;
 762                 while (left) {
 763                         char c;
 764                         if(get_user(c, p++))
 765                                 return -EFAULT;
 766                         if (!isspace(c))
 767                                 break;
 768                         left--;
 769                 }
 770         }
 771         if (write && first)
 772                 return -EINVAL;
 773         *lenp -= left;
 774         filp->f_pos += *lenp;
 775         return 0;
 776 }
 777
 778 int proc_dointvec(ctl_table *table, int write, struct file *filp,
 779                      void *buffer, size_t *lenp)
 780 {
 781     return do_proc_dointvec(table,write,filp,buffer,lenp,1);
 782 }
 783
 784 int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
 785                   void *buffer, size_t *lenp)
 786 {
 787         int *i, *min, *max, vleft, first=1, len, left, neg, val;
 788         #define TMPBUFLEN 20
 789         char buf[TMPBUFLEN], *p;
 790
 791         if (!table->data || !table->maxlen || !*lenp ||
 792             (filp->f_pos && !write)) {
 793                 *lenp = 0;
 794                 return 0;
 795         }
 796
 797         i = (int *) table->data;
 798         min = (int *) table->extra1;
 799         max = (int *) table->extra2;
 800         vleft = table->maxlen / sizeof(int);
 801         left = *lenp;
 802
 803         for (; left && vleft--; i++, first=0) {
 804                 if (write) {
 805                         while (left) {
 806                                 char c;
 807                                 if(get_user(c, (char *) buffer))
 808                                         return -EFAULT;
 809                                 if (!isspace(c))
 810                                         break;
 811                                 left--;
 812                                 ((char *) buffer)++;
 813                         }
 814                         if (!left)
 815                                 break;
 816                         neg = 0;
 817                         len = left;
 818                         if (len > TMPBUFLEN-1)
 819                                 len = TMPBUFLEN-1;
 820                         if(copy_from_user(buf, buffer, len))
 821                                 return -EFAULT;
 822                         buf[len] = 0;
 823                         p = buf;
 824                         if (*p == '-' && left > 1) {
 825                                 neg = 1;
 826                                 left--, p++;
 827                         }
 828                         if (*p < '0' || *p > '9')
 829                                 break;
 830                         val = simple_strtoul(p, &p, 0);
 831                         len = p-buf;
 832                         if ((len < left) && *p && !isspace(*p))
 833                                 break;
 834                         if (neg)
 835                                 val = -val;
 836                         buffer += len;
 837                         left -= len;
 838
 839                         if (min && val < *min++)
 840                                 continue;
 841                         if (max && val > *max++)
 842                                 continue;
 843                         *i = val;
 844                 } else {
 845                         p = buf;
 846                         if (!first)
 847                                 *p++ = '\t';
 848                         sprintf(p, "%d", *i);
 849                         len = strlen(buf);
 850                         if (len > left)
 851                                 len = left;
 852                         if(copy_to_user(buffer, buf, len))
 853                                 return -EFAULT;
 854                         left -= len;
 855                         buffer += len;
 856                 }
 857         }
 858
 859         if (!write && !first && left) {
 860                 if(put_user('\n', (char *) buffer))
 861                         return -EFAULT;
 862                 left--, buffer++;
 863         }
 864         if (write) {
 865                 p = (char *) buffer;
 866                 while (left) {
 867                         char c;
 868                         if(get_user(c, p++))
 869                                 return -EFAULT;
 870                         if (!isspace(c))
 871                                 break;
 872                         left--;
 873                 }
 874         }
 875         if (write && first)
 876                 return -EINVAL;
 877         *lenp -= left;
 878         filp->f_pos += *lenp;
 879         return 0;
 880 }
 881
 882 /* Like proc_dointvec, but converts seconds to jiffies */
 883 int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
 884                           void *buffer, size_t *lenp)
 885 {
 886     return do_proc_dointvec(table,write,filp,buffer,lenp,HZ);
 887 }
 888
 889 #else /* CONFIG_PROC_FS */
 890
 891 int proc_dostring(ctl_table *table, int write, struct file *filp,
 892                   void *buffer, size_t *lenp)
 893 {
 894         return -ENOSYS;
 895 }
 896
 897 static int proc_doutsstring(ctl_table *table, int write, struct file *filp,
 898                             void *buffer, size_t *lenp)
 899 {
 900         return -ENOSYS;
 901 }
 902
 903 int proc_dointvec(ctl_table *table, int write, struct file *filp,
 904                   void *buffer, size_t *lenp)
 905 {
 906         return -ENOSYS;
 907 }
 908
 909 int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
 910                     void *buffer, size_t *lenp)
 911 {
 912         return -ENOSYS;
 913 }
 914
 915 int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
 916                     void *buffer, size_t *lenp)
 917 {
 918         return -ENOSYS;
 919 }
 920
 921 #endif /* CONFIG_PROC_FS */
 922
 923
 924 /*
 925  * General sysctl support routines
 926  */
 927
 928 /* The generic string strategy routine: */
 929 int sysctl_string(ctl_table *table, int *name, int nlen,
 930                   void *oldval, size_t *oldlenp,
 931                   void *newval, size_t newlen, void **context)
 932 {
 933         int l, len;
 934
 935         if (!table->data || !table->maxlen)
 936                 return -ENOTDIR;
 937
 938         if (oldval && oldlenp) {
 939                 if(get_user(len, oldlenp))
 940                         return -EFAULT;
 941                 if (len) {
 942                         l = strlen(table->data);
 943                         if (len > l) len = l;
 944                         if (len >= table->maxlen)
 945                                 len = table->maxlen;
 946                         if(copy_to_user(oldval, table->data, len))
 947                                 return -EFAULT;
 948                         if(put_user(0, ((char *) oldval) + len))
 949                                 return -EFAULT;
 950                         if(put_user(len, oldlenp))
 951                                 return -EFAULT;
 952                 }
 953         }
 954         if (newval && newlen) {
 955                 len = newlen;
 956                 if (len > table->maxlen)
 957                         len = table->maxlen;
 958                 if(copy_from_user(table->data, newval, len))
 959                         return -EFAULT;
 960                 if (len == table->maxlen)
 961                         len--;
 962                 ((char *) table->data)[len] = 0;
 963         }
 964         return 0;
 965 }
 966
 967 /*
 968  * This function makes sure that all of the integers in the vector
 969  * are between the minimum and maximum values given in the arrays
 970  * table->extra1 and table->extra2, respectively.
 971  */
 972 int sysctl_intvec(ctl_table *table, int *name, int nlen,
 973                 void *oldval, size_t *oldlenp,
 974                 void *newval, size_t newlen, void **context)
 975 {
 976         int i, length, *vec, *min, *max;
 977
 978         if (newval && newlen) {
 979                 if (newlen % sizeof(int) != 0)
 980                         return -EINVAL;
 981
 982                 if (!table->extra1 && !table->extra2)
 983                         return 0;
 984
 985                 if (newlen > table->maxlen)
 986                         newlen = table->maxlen;
 987                 length = newlen / sizeof(int);
 988
 989                 vec = (int *) newval;
 990                 min = (int *) table->extra1;
 991                 max = (int *) table->extra2;
 992
 993                 for (i = 0; i < length; i++) {
 994                         int value;
 995                         get_user(value, vec + i);
 996                         if (min && value < min[i])
 997                                 return -EINVAL;
 998                         if (max && value > max[i])
 999                                 return -EINVAL;
1000                 }
1001         }
1002         return 0;
1003 }
1004
1005 int do_string (
1006         void *oldval, size_t *oldlenp, void *newval, size_t newlen,
1007         int rdwr, char *data, size_t max)
1008 {
1009         int l = strlen(data) + 1;
1010         if (newval && !rdwr)
1011                 return -EPERM;
1012         if (newval && newlen >= max)
1013                 return -EINVAL;
1014         if (oldval) {
1015                 int old_l;
1016                 if(get_user(old_l, oldlenp))
1017                         return -EFAULT;
1018                 if (l > old_l)
1019                         return -ENOMEM;
1020                 if(put_user(l, oldlenp) || copy_to_user(oldval, data, l))
1021                         return -EFAULT;
1022         }
1023         if (newval) {
1024                 if(copy_from_user(data, newval, newlen))
1025                         return -EFAULT;
1026                 data[newlen] = 0;
1027         }
1028         return 0;
1029 }
1030
1031 int do_int (
1032         void *oldval, size_t *oldlenp, void *newval, size_t newlen,
1033         int rdwr, int *data)
1034 {
1035         if (newval && !rdwr)
1036                 return -EPERM;
1037         if (newval && newlen != sizeof(int))
1038                 return -EINVAL;
1039         if (oldval) {
1040                 int old_l;
1041                 if(get_user(old_l, oldlenp))
1042                         return -EFAULT;
1043                 if (old_l < sizeof(int))
1044                         return -ENOMEM;
1045                 if(put_user(sizeof(int), oldlenp)||copy_to_user(oldval, data, sizeof(int)))
1046                         return -EFAULT;
1047         }
1048         if (newval)
1049                 if(copy_from_user(data, newval, sizeof(int)))
1050                         return -EFAULT;
1051         return 0;
1052 }
1053
1054 int do_struct (
1055         void *oldval, size_t *oldlenp, void *newval, size_t newlen,
1056         int rdwr, void *data, size_t len)
1057 {
1058         if (newval && !rdwr)
1059                 return -EPERM;
1060         if (newval && newlen != len)
1061                 return -EINVAL;
1062         if (oldval) {
1063                 int old_l;
1064                 if(get_user(old_l, oldlenp))
1065                         return -EFAULT;
1066                 if (old_l < len)
1067                         return -ENOMEM;
1068                 if(put_user(len, oldlenp) || copy_to_user(oldval, data, len))
1069                         return -EFAULT;
1070         }
1071         if (newval)
1072                 if(copy_from_user(data, newval, len))
1073                         return -EFAULT;
1074         return 0;
1075 }
1076
1077
1078 #else /* CONFIG_SYSCTL */
1079
1080
1081 extern asmlinkage int sys_sysctl(struct __sysctl_args *args)
1082 {
1083         return -ENOSYS;
1084 }
1085
1086 int sysctl_string(ctl_table *table, int *name, int nlen,
1087                   void *oldval, size_t *oldlenp,
1088                   void *newval, size_t newlen, void **context)
1089 {
1090         return -ENOSYS;
1091 }
1092
1093 int sysctl_intvec(ctl_table *table, int *name, int nlen,
1094                 void *oldval, size_t *oldlenp,
1095                 void *newval, size_t newlen, void **context)
1096 {
1097         return -ENOSYS;
1098 }
1099
1100 int proc_dostring(ctl_table *table, int write, struct file *filp,
1101                   void *buffer, size_t *lenp)
1102 {
1103         return -ENOSYS;
1104 }
1105
1106 int proc_dointvec(ctl_table *table, int write, struct file *filp,
1107                   void *buffer, size_t *lenp)
1108 {
1109         return -ENOSYS;
1110 }
1111
1112 int proc_dointvec_minmax(ctl_table *table, int write, struct file *filp,
1113                     void *buffer, size_t *lenp)
1114 {
1115         return -ENOSYS;
1116 }
1117
1118 int proc_dointvec_jiffies(ctl_table *table, int write, struct file *filp,
1119                     void *buffer, size_t *lenp)
1120 {
1121         return -ENOSYS;
1122 }
1123
1124 struct ctl_table_header * register_sysctl_table(ctl_table * table,
1125                                                 int insert_at_head)
1126 {
1127         return 0;
1128 }
1129
1130 void unregister_sysctl_table(struct ctl_table_header * table)
1131 {
1132 }
1133
1134 #endif /* CONFIG_SYSCTL */