1 /* $NetBSD: kern_sysctl.c,v 1.7 1995/01/25 06:08:06 cgd Exp $ */ 2 3 /*- 4 * Copyright (c) 1982, 1986, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Mike Karels at Berkeley Software Design, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94 39 */ 40 41 /* 42 * sysctl system call. 43 */ 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/kernel.h> 48 #include <sys/malloc.h> 49 #include <sys/proc.h> 50 #include <sys/file.h> 51 #include <sys/vnode.h> 52 #include <sys/unistd.h> 53 #include <sys/buf.h> 54 #include <sys/ioctl.h> 55 #include <sys/tty.h> 56 #include <sys/disklabel.h> 57 #include <vm/vm.h> 58 #include <sys/sysctl.h> 59 60 #include <sys/mount.h> 61 #include <sys/syscallargs.h> 62 63 sysctlfn kern_sysctl; 64 sysctlfn hw_sysctl; 65 #ifdef DEBUG 66 sysctlfn debug_sysctl; 67 #endif 68 extern sysctlfn vm_sysctl; 69 extern sysctlfn fs_sysctl; 70 extern sysctlfn net_sysctl; 71 extern sysctlfn cpu_sysctl; 72 73 /* 74 * Locking and stats 75 */ 76 static struct sysctl_lock { 77 int sl_lock; 78 int sl_want; 79 int sl_locked; 80 } memlock; 81 82 int 83 __sysctl(p, uap, retval) 84 struct proc *p; 85 register struct __sysctl_args /* { 86 syscallarg(int *) name; 87 syscallarg(u_int) namelen; 88 syscallarg(void *) old; 89 syscallarg(size_t *) oldlenp; 90 syscallarg(void *) new; 91 syscallarg(size_t) newlen; 92 } */ *uap; 93 register_t *retval; 94 { 95 int error, dolock = 1; 96 size_t savelen, oldlen = 0; 97 sysctlfn *fn; 98 int name[CTL_MAXNAME]; 99 100 if (SCARG(uap, new) != NULL && 101 (error = suser(p->p_ucred, &p->p_acflag))) 102 return (error); 103 /* 104 * all top-level sysctl names are non-terminal 105 */ 106 if (SCARG(uap, namelen) > CTL_MAXNAME || SCARG(uap, namelen) < 2) 107 return (EINVAL); 108 if (error = 109 copyin(SCARG(uap, name), &name, SCARG(uap, namelen) * sizeof(int))) 110 return (error); 111 112 switch (name[0]) { 113 case CTL_KERN: 114 fn = kern_sysctl; 115 if (name[2] != KERN_VNODE) /* XXX */ 116 dolock = 0; 117 break; 118 case CTL_HW: 119 fn = hw_sysctl; 120 break; 121 case CTL_VM: 122 fn = vm_sysctl; 123 break; 124 case CTL_NET: 125 fn = net_sysctl; 126 break; 127 #ifdef notyet 128 case CTL_FS: 129 fn = fs_sysctl; 130 break; 131 #endif 132 case CTL_MACHDEP: 133 fn = cpu_sysctl; 134 break; 135 #ifdef DEBUG 136 case CTL_DEBUG: 137 fn = debug_sysctl; 138 break; 139 #endif 140 default: 141 return (EOPNOTSUPP); 142 } 143 144 if (SCARG(uap, oldlenp) && 145 (error = copyin(SCARG(uap, oldlenp), &oldlen, sizeof(oldlen)))) 146 return (error); 147 if (SCARG(uap, old) != NULL) { 148 if (!useracc(SCARG(uap, old), oldlen, B_WRITE)) 149 return (EFAULT); 150 while (memlock.sl_lock) { 151 memlock.sl_want = 1; 152 sleep((caddr_t)&memlock, PRIBIO+1); 153 memlock.sl_locked++; 154 } 155 memlock.sl_lock = 1; 156 if (dolock) 157 vslock(SCARG(uap, old), oldlen); 158 savelen = oldlen; 159 } 160 error = (*fn)(name + 1, SCARG(uap, namelen) - 1, SCARG(uap, old), 161 &oldlen, SCARG(uap, new), SCARG(uap, newlen), p); 162 if (SCARG(uap, old) != NULL) { 163 if (dolock) 164 vsunlock(SCARG(uap, old), savelen, B_WRITE); 165 memlock.sl_lock = 0; 166 if (memlock.sl_want) { 167 memlock.sl_want = 0; 168 wakeup((caddr_t)&memlock); 169 } 170 } 171 if (error) 172 return (error); 173 if (SCARG(uap, oldlenp)) 174 error = copyout(&oldlen, SCARG(uap, oldlenp), sizeof(oldlen)); 175 *retval = oldlen; 176 return (0); 177 } 178 179 /* 180 * Attributes stored in the kernel. 181 */ 182 char hostname[MAXHOSTNAMELEN]; 183 int hostnamelen; 184 char domainname[MAXHOSTNAMELEN]; 185 int domainnamelen; 186 long hostid; 187 int securelevel; 188 189 /* 190 * kernel related system variables. 191 */ 192 kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 193 int *name; 194 u_int namelen; 195 void *oldp; 196 size_t *oldlenp; 197 void *newp; 198 size_t newlen; 199 struct proc *p; 200 { 201 int error, level, inthostid; 202 extern char ostype[], osrelease[], version[]; 203 204 /* all sysctl names at this level are terminal */ 205 if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF)) 206 return (ENOTDIR); /* overloaded */ 207 208 switch (name[0]) { 209 case KERN_OSTYPE: 210 return (sysctl_rdstring(oldp, oldlenp, newp, ostype)); 211 case KERN_OSRELEASE: 212 return (sysctl_rdstring(oldp, oldlenp, newp, osrelease)); 213 case KERN_OSREV: 214 return (sysctl_rdint(oldp, oldlenp, newp, BSD)); 215 case KERN_VERSION: 216 return (sysctl_rdstring(oldp, oldlenp, newp, version)); 217 case KERN_MAXVNODES: 218 return(sysctl_int(oldp, oldlenp, newp, newlen, &desiredvnodes)); 219 case KERN_MAXPROC: 220 return (sysctl_int(oldp, oldlenp, newp, newlen, &maxproc)); 221 case KERN_MAXFILES: 222 return (sysctl_int(oldp, oldlenp, newp, newlen, &maxfiles)); 223 case KERN_ARGMAX: 224 return (sysctl_rdint(oldp, oldlenp, newp, ARG_MAX)); 225 case KERN_SECURELVL: 226 level = securelevel; 227 if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) || 228 newp == NULL) 229 return (error); 230 if (level < securelevel && p->p_pid != 1) 231 return (EPERM); 232 securelevel = level; 233 return (0); 234 case KERN_HOSTNAME: 235 error = sysctl_string(oldp, oldlenp, newp, newlen, 236 hostname, sizeof(hostname)); 237 if (newp && !error) 238 hostnamelen = newlen; 239 return (error); 240 case KERN_DOMAINNAME: 241 error = sysctl_string(oldp, oldlenp, newp, newlen, 242 domainname, sizeof(domainname)); 243 if (newp && !error) 244 domainnamelen = newlen; 245 return (error); 246 case KERN_HOSTID: 247 inthostid = hostid; /* XXX assumes sizeof long <= sizeof int */ 248 error = sysctl_int(oldp, oldlenp, newp, newlen, &inthostid); 249 hostid = inthostid; 250 return (error); 251 case KERN_CLOCKRATE: 252 return (sysctl_clockrate(oldp, oldlenp)); 253 case KERN_BOOTTIME: 254 return (sysctl_rdstruct(oldp, oldlenp, newp, &boottime, 255 sizeof(struct timeval))); 256 case KERN_VNODE: 257 return (sysctl_vnode(oldp, oldlenp)); 258 case KERN_PROC: 259 return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp)); 260 case KERN_FILE: 261 return (sysctl_file(oldp, oldlenp)); 262 #ifdef GPROF 263 case KERN_PROF: 264 return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp, 265 newp, newlen)); 266 #endif 267 case KERN_POSIX1: 268 return (sysctl_rdint(oldp, oldlenp, newp, _POSIX_VERSION)); 269 case KERN_NGROUPS: 270 return (sysctl_rdint(oldp, oldlenp, newp, NGROUPS_MAX)); 271 case KERN_JOB_CONTROL: 272 return (sysctl_rdint(oldp, oldlenp, newp, 1)); 273 case KERN_SAVED_IDS: 274 #ifdef _POSIX_SAVED_IDS 275 return (sysctl_rdint(oldp, oldlenp, newp, 1)); 276 #else 277 return (sysctl_rdint(oldp, oldlenp, newp, 0)); 278 #endif 279 case KERN_MAXPARTITIONS: 280 return (sysctl_rdint(oldp, oldlenp, newp, MAXPARTITIONS)); 281 default: 282 return (EOPNOTSUPP); 283 } 284 /* NOTREACHED */ 285 } 286 287 /* 288 * hardware related system variables. 289 */ 290 hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 291 int *name; 292 u_int namelen; 293 void *oldp; 294 size_t *oldlenp; 295 void *newp; 296 size_t newlen; 297 struct proc *p; 298 { 299 extern char machine[], cpu_model[]; 300 301 /* all sysctl names at this level are terminal */ 302 if (namelen != 1) 303 return (ENOTDIR); /* overloaded */ 304 305 switch (name[0]) { 306 case HW_MACHINE: 307 return (sysctl_rdstring(oldp, oldlenp, newp, machine)); 308 case HW_MODEL: 309 return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model)); 310 case HW_NCPU: 311 return (sysctl_rdint(oldp, oldlenp, newp, 1)); /* XXX */ 312 case HW_BYTEORDER: 313 return (sysctl_rdint(oldp, oldlenp, newp, BYTE_ORDER)); 314 case HW_PHYSMEM: 315 return (sysctl_rdint(oldp, oldlenp, newp, ctob(physmem))); 316 case HW_USERMEM: 317 return (sysctl_rdint(oldp, oldlenp, newp, 318 ctob(physmem - cnt.v_wire_count))); 319 case HW_PAGESIZE: 320 return (sysctl_rdint(oldp, oldlenp, newp, PAGE_SIZE)); 321 default: 322 return (EOPNOTSUPP); 323 } 324 /* NOTREACHED */ 325 } 326 327 #ifdef DEBUG 328 /* 329 * Debugging related system variables. 330 */ 331 struct ctldebug debug0, debug1, debug2, debug3, debug4; 332 struct ctldebug debug5, debug6, debug7, debug8, debug9; 333 struct ctldebug debug10, debug11, debug12, debug13, debug14; 334 struct ctldebug debug15, debug16, debug17, debug18, debug19; 335 static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = { 336 &debug0, &debug1, &debug2, &debug3, &debug4, 337 &debug5, &debug6, &debug7, &debug8, &debug9, 338 &debug10, &debug11, &debug12, &debug13, &debug14, 339 &debug15, &debug16, &debug17, &debug18, &debug19, 340 }; 341 int 342 debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 343 int *name; 344 u_int namelen; 345 void *oldp; 346 size_t *oldlenp; 347 void *newp; 348 size_t newlen; 349 struct proc *p; 350 { 351 struct ctldebug *cdp; 352 353 /* all sysctl names at this level are name and field */ 354 if (namelen != 2) 355 return (ENOTDIR); /* overloaded */ 356 cdp = debugvars[name[0]]; 357 if (cdp->debugname == 0) 358 return (EOPNOTSUPP); 359 switch (name[1]) { 360 case CTL_DEBUG_NAME: 361 return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname)); 362 case CTL_DEBUG_VALUE: 363 return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar)); 364 default: 365 return (EOPNOTSUPP); 366 } 367 /* NOTREACHED */ 368 } 369 #endif /* DEBUG */ 370 371 /* 372 * Validate parameters and get old / set new parameters 373 * for an integer-valued sysctl function. 374 */ 375 sysctl_int(oldp, oldlenp, newp, newlen, valp) 376 void *oldp; 377 size_t *oldlenp; 378 void *newp; 379 size_t newlen; 380 int *valp; 381 { 382 int error = 0; 383 384 if (oldp && *oldlenp < sizeof(int)) 385 return (ENOMEM); 386 if (newp && newlen != sizeof(int)) 387 return (EINVAL); 388 *oldlenp = sizeof(int); 389 if (oldp) 390 error = copyout(valp, oldp, sizeof(int)); 391 if (error == 0 && newp) 392 error = copyin(newp, valp, sizeof(int)); 393 return (error); 394 } 395 396 /* 397 * As above, but read-only. 398 */ 399 sysctl_rdint(oldp, oldlenp, newp, val) 400 void *oldp; 401 size_t *oldlenp; 402 void *newp; 403 int val; 404 { 405 int error = 0; 406 407 if (oldp && *oldlenp < sizeof(int)) 408 return (ENOMEM); 409 if (newp) 410 return (EPERM); 411 *oldlenp = sizeof(int); 412 if (oldp) 413 error = copyout((caddr_t)&val, oldp, sizeof(int)); 414 return (error); 415 } 416 417 /* 418 * Validate parameters and get old / set new parameters 419 * for a string-valued sysctl function. 420 */ 421 sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen) 422 void *oldp; 423 size_t *oldlenp; 424 void *newp; 425 size_t newlen; 426 char *str; 427 int maxlen; 428 { 429 int len, error = 0; 430 431 len = strlen(str) + 1; 432 if (oldp && *oldlenp < len) 433 return (ENOMEM); 434 if (newp && newlen >= maxlen) 435 return (EINVAL); 436 if (oldp) { 437 *oldlenp = len; 438 error = copyout(str, oldp, len); 439 } 440 if (error == 0 && newp) { 441 error = copyin(newp, str, newlen); 442 str[newlen] = 0; 443 } 444 return (error); 445 } 446 447 /* 448 * As above, but read-only. 449 */ 450 sysctl_rdstring(oldp, oldlenp, newp, str) 451 void *oldp; 452 size_t *oldlenp; 453 void *newp; 454 char *str; 455 { 456 int len, error = 0; 457 458 len = strlen(str) + 1; 459 if (oldp && *oldlenp < len) 460 return (ENOMEM); 461 if (newp) 462 return (EPERM); 463 *oldlenp = len; 464 if (oldp) 465 error = copyout(str, oldp, len); 466 return (error); 467 } 468 469 /* 470 * Validate parameters and get old / set new parameters 471 * for a structure oriented sysctl function. 472 */ 473 sysctl_struct(oldp, oldlenp, newp, newlen, sp, len) 474 void *oldp; 475 size_t *oldlenp; 476 void *newp; 477 size_t newlen; 478 void *sp; 479 int len; 480 { 481 int error = 0; 482 483 if (oldp && *oldlenp < len) 484 return (ENOMEM); 485 if (newp && newlen > len) 486 return (EINVAL); 487 if (oldp) { 488 *oldlenp = len; 489 error = copyout(sp, oldp, len); 490 } 491 if (error == 0 && newp) 492 error = copyin(newp, sp, len); 493 return (error); 494 } 495 496 /* 497 * Validate parameters and get old parameters 498 * for a structure oriented sysctl function. 499 */ 500 sysctl_rdstruct(oldp, oldlenp, newp, sp, len) 501 void *oldp; 502 size_t *oldlenp; 503 void *newp, *sp; 504 int len; 505 { 506 int error = 0; 507 508 if (oldp && *oldlenp < len) 509 return (ENOMEM); 510 if (newp) 511 return (EPERM); 512 *oldlenp = len; 513 if (oldp) 514 error = copyout(sp, oldp, len); 515 return (error); 516 } 517 518 /* 519 * Get file structures. 520 */ 521 sysctl_file(where, sizep) 522 char *where; 523 size_t *sizep; 524 { 525 int buflen, error; 526 struct file *fp; 527 char *start = where; 528 529 buflen = *sizep; 530 if (where == NULL) { 531 /* 532 * overestimate by 10 files 533 */ 534 *sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file); 535 return (0); 536 } 537 538 /* 539 * first copyout filehead 540 */ 541 if (buflen < sizeof(filehead)) { 542 *sizep = 0; 543 return (0); 544 } 545 if (error = copyout((caddr_t)&filehead, where, sizeof(filehead))) 546 return (error); 547 buflen -= sizeof(filehead); 548 where += sizeof(filehead); 549 550 /* 551 * followed by an array of file structures 552 */ 553 for (fp = filehead.lh_first; fp != 0; fp = fp->f_list.le_next) { 554 if (buflen < sizeof(struct file)) { 555 *sizep = where - start; 556 return (ENOMEM); 557 } 558 if (error = copyout((caddr_t)fp, where, sizeof (struct file))) 559 return (error); 560 buflen -= sizeof(struct file); 561 where += sizeof(struct file); 562 } 563 *sizep = where - start; 564 return (0); 565 } 566 567 /* 568 * try over estimating by 5 procs 569 */ 570 #define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc)) 571 572 sysctl_doproc(name, namelen, where, sizep) 573 int *name; 574 u_int namelen; 575 char *where; 576 size_t *sizep; 577 { 578 register struct proc *p; 579 register struct kinfo_proc *dp = (struct kinfo_proc *)where; 580 register int needed = 0; 581 int buflen = where != NULL ? *sizep : 0; 582 int doingzomb; 583 struct eproc eproc; 584 int error = 0; 585 586 if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL)) 587 return (EINVAL); 588 p = allproc.lh_first; 589 doingzomb = 0; 590 again: 591 for (; p != 0; p = p->p_list.le_next) { 592 /* 593 * Skip embryonic processes. 594 */ 595 if (p->p_stat == SIDL) 596 continue; 597 /* 598 * TODO - make more efficient (see notes below). 599 * do by session. 600 */ 601 switch (name[0]) { 602 603 case KERN_PROC_PID: 604 /* could do this with just a lookup */ 605 if (p->p_pid != (pid_t)name[1]) 606 continue; 607 break; 608 609 case KERN_PROC_PGRP: 610 /* could do this by traversing pgrp */ 611 if (p->p_pgrp->pg_id != (pid_t)name[1]) 612 continue; 613 break; 614 615 case KERN_PROC_TTY: 616 if ((p->p_flag & P_CONTROLT) == 0 || 617 p->p_session->s_ttyp == NULL || 618 p->p_session->s_ttyp->t_dev != (dev_t)name[1]) 619 continue; 620 break; 621 622 case KERN_PROC_UID: 623 if (p->p_ucred->cr_uid != (uid_t)name[1]) 624 continue; 625 break; 626 627 case KERN_PROC_RUID: 628 if (p->p_cred->p_ruid != (uid_t)name[1]) 629 continue; 630 break; 631 } 632 if (buflen >= sizeof(struct kinfo_proc)) { 633 fill_eproc(p, &eproc); 634 if (error = copyout((caddr_t)p, &dp->kp_proc, 635 sizeof(struct proc))) 636 return (error); 637 if (error = copyout((caddr_t)&eproc, &dp->kp_eproc, 638 sizeof(eproc))) 639 return (error); 640 dp++; 641 buflen -= sizeof(struct kinfo_proc); 642 } 643 needed += sizeof(struct kinfo_proc); 644 } 645 if (doingzomb == 0) { 646 p = zombproc.lh_first; 647 doingzomb++; 648 goto again; 649 } 650 if (where != NULL) { 651 *sizep = (caddr_t)dp - where; 652 if (needed > *sizep) 653 return (ENOMEM); 654 } else { 655 needed += KERN_PROCSLOP; 656 *sizep = needed; 657 } 658 return (0); 659 } 660 661 /* 662 * Fill in an eproc structure for the specified process. 663 */ 664 void 665 fill_eproc(p, ep) 666 register struct proc *p; 667 register struct eproc *ep; 668 { 669 register struct tty *tp; 670 671 ep->e_paddr = p; 672 ep->e_sess = p->p_pgrp->pg_session; 673 ep->e_pcred = *p->p_cred; 674 ep->e_ucred = *p->p_ucred; 675 if (p->p_stat == SIDL || p->p_stat == SZOMB) { 676 ep->e_vm.vm_rssize = 0; 677 ep->e_vm.vm_tsize = 0; 678 ep->e_vm.vm_dsize = 0; 679 ep->e_vm.vm_ssize = 0; 680 /* ep->e_vm.vm_pmap = XXX; */ 681 } else { 682 register struct vmspace *vm = p->p_vmspace; 683 684 #ifdef pmap_resident_count 685 ep->e_vm.vm_rssize = pmap_resident_count(&vm->vm_pmap); /*XXX*/ 686 #else 687 ep->e_vm.vm_rssize = vm->vm_rssize; 688 #endif 689 ep->e_vm.vm_tsize = vm->vm_tsize; 690 ep->e_vm.vm_dsize = vm->vm_dsize; 691 ep->e_vm.vm_ssize = vm->vm_ssize; 692 ep->e_vm.vm_pmap = vm->vm_pmap; 693 } 694 if (p->p_pptr) 695 ep->e_ppid = p->p_pptr->p_pid; 696 else 697 ep->e_ppid = 0; 698 ep->e_pgid = p->p_pgrp->pg_id; 699 ep->e_jobc = p->p_pgrp->pg_jobc; 700 if ((p->p_flag & P_CONTROLT) && 701 (tp = ep->e_sess->s_ttyp)) { 702 ep->e_tdev = tp->t_dev; 703 ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 704 ep->e_tsess = tp->t_session; 705 } else 706 ep->e_tdev = NODEV; 707 ep->e_flag = ep->e_sess->s_ttyvp ? EPROC_CTTY : 0; 708 if (SESS_LEADER(p)) 709 ep->e_flag |= EPROC_SLEADER; 710 if (p->p_wmesg) 711 strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN); 712 ep->e_xsize = ep->e_xrssize = 0; 713 ep->e_xccount = ep->e_xswrss = 0; 714 } 715 716 #ifdef COMPAT_43 717 #include <sys/socket.h> 718 #define KINFO_PROC (0<<8) 719 #define KINFO_RT (1<<8) 720 #define KINFO_VNODE (2<<8) 721 #define KINFO_FILE (3<<8) 722 #define KINFO_METER (4<<8) 723 #define KINFO_LOADAVG (5<<8) 724 #define KINFO_CLOCKRATE (6<<8) 725 726 compat_43_getkerninfo(p, uap, retval) 727 struct proc *p; 728 register struct compat_43_getkerninfo_args /* { 729 syscallarg(int) op; 730 syscallarg(char *) where; 731 syscallarg(int *) size; 732 syscallarg(int) arg; 733 } */ *uap; 734 register_t *retval; 735 { 736 int error, name[5]; 737 size_t size; 738 739 if (SCARG(uap, size) && (error = copyin((caddr_t)SCARG(uap, size), 740 (caddr_t)&size, sizeof(size)))) 741 return (error); 742 743 switch (SCARG(uap, op) & 0xff00) { 744 745 case KINFO_RT: 746 name[0] = PF_ROUTE; 747 name[1] = 0; 748 name[2] = (SCARG(uap, op) & 0xff0000) >> 16; 749 name[3] = SCARG(uap, op) & 0xff; 750 name[4] = SCARG(uap, arg); 751 error = 752 net_sysctl(name, 5, SCARG(uap, where), &size, NULL, 0, p); 753 break; 754 755 case KINFO_VNODE: 756 name[0] = KERN_VNODE; 757 error = 758 kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p); 759 break; 760 761 case KINFO_PROC: 762 name[0] = KERN_PROC; 763 name[1] = SCARG(uap, op) & 0xff; 764 name[2] = SCARG(uap, arg); 765 error = 766 kern_sysctl(name, 3, SCARG(uap, where), &size, NULL, 0, p); 767 break; 768 769 case KINFO_FILE: 770 name[0] = KERN_FILE; 771 error = 772 kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p); 773 break; 774 775 case KINFO_METER: 776 name[0] = VM_METER; 777 error = 778 vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p); 779 break; 780 781 case KINFO_LOADAVG: 782 name[0] = VM_LOADAVG; 783 error = 784 vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p); 785 break; 786 787 case KINFO_CLOCKRATE: 788 name[0] = KERN_CLOCKRATE; 789 error = 790 kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p); 791 break; 792 793 default: 794 return (EOPNOTSUPP); 795 } 796 if (error) 797 return (error); 798 *retval = size; 799 if (SCARG(uap, size)) 800 error = copyout((caddr_t)&size, (caddr_t)SCARG(uap, size), 801 sizeof(size)); 802 return (error); 803 } 804 #endif /* COMPAT_43 */ 805