init_sysctl.c revision 1.22
1 /* $NetBSD: init_sysctl.c,v 1.22 2004/02/21 03:27:57 atatat Exp $ */ 2 3 /*- 4 * Copyright (c) 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Brown. 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 NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: init_sysctl.c,v 1.22 2004/02/21 03:27:57 atatat Exp $"); 41 42 #include "opt_sysv.h" 43 #include "opt_multiprocessor.h" 44 #include "opt_posix.h" 45 #include "pty.h" 46 #include "rnd.h" 47 48 #include <sys/types.h> 49 #include <sys/param.h> 50 #include <sys/sysctl.h> 51 #include <sys/errno.h> 52 #include <sys/systm.h> 53 #include <sys/kernel.h> 54 #include <sys/unistd.h> 55 #include <sys/disklabel.h> 56 #include <sys/rnd.h> 57 #include <sys/vnode.h> 58 #include <sys/mount.h> 59 #include <sys/namei.h> 60 #include <sys/msgbuf.h> 61 #include <dev/cons.h> 62 #include <sys/socketvar.h> 63 #include <sys/file.h> 64 #include <sys/tty.h> 65 #include <sys/malloc.h> 66 #include <sys/resource.h> 67 #include <sys/resourcevar.h> 68 #include <sys/exec.h> 69 #include <sys/conf.h> 70 #include <sys/device.h> 71 72 #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) 73 #include <sys/ipc.h> 74 #endif 75 #ifdef SYSVMSG 76 #include <sys/msg.h> 77 #endif 78 #ifdef SYSVSEM 79 #include <sys/sem.h> 80 #endif 81 #ifdef SYSVSHM 82 #include <sys/shm.h> 83 #endif 84 85 #include <machine/cpu.h> 86 87 /* 88 * try over estimating by 5 procs/lwps 89 */ 90 #define KERN_PROCSLOP (5 * sizeof(struct kinfo_proc)) 91 #define KERN_LWPSLOP (5 * sizeof(struct kinfo_lwp)) 92 93 #ifndef MULTIPROCESSOR 94 #define sysctl_ncpus() (1) 95 #else /* MULTIPROCESSOR */ 96 #ifndef CPU_INFO_FOREACH 97 #define CPU_INFO_ITERATOR int 98 #define CPU_INFO_FOREACH(cii, ci) cii = 0, ci = curcpu(); ci != NULL; ci = NULL 99 #endif 100 static int 101 sysctl_ncpus(void) 102 { 103 struct cpu_info *ci; 104 CPU_INFO_ITERATOR cii; 105 106 int ncpus = 0; 107 for (CPU_INFO_FOREACH(cii, ci)) 108 ncpus++; 109 return (ncpus); 110 } 111 #endif /* MULTIPROCESSOR */ 112 113 static int sysctl_kern_maxvnodes(SYSCTLFN_PROTO); 114 static int sysctl_kern_rtc_offset(SYSCTLFN_PROTO); 115 static int sysctl_kern_maxproc(SYSCTLFN_PROTO); 116 static int sysctl_kern_securelevel(SYSCTLFN_PROTO); 117 static int sysctl_kern_hostid(SYSCTLFN_PROTO); 118 static int sysctl_setlen(SYSCTLFN_PROTO); 119 static int sysctl_kern_clockrate(SYSCTLFN_PROTO); 120 static int sysctl_kern_file(SYSCTLFN_PROTO); 121 static int sysctl_kern_autonice(SYSCTLFN_PROTO); 122 static int sysctl_msgbuf(SYSCTLFN_PROTO); 123 static int sysctl_kern_defcorename(SYSCTLFN_PROTO); 124 static int sysctl_kern_cptime(SYSCTLFN_PROTO); 125 #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) 126 static int sysctl_kern_sysvipc(SYSCTLFN_PROTO); 127 #endif /* defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) */ 128 #if NPTY > 0 129 static int sysctl_kern_maxptys(SYSCTLFN_PROTO); 130 #endif /* NPTY > 0 */ 131 static int sysctl_kern_sbmax(SYSCTLFN_PROTO); 132 static int sysctl_kern_urnd(SYSCTLFN_PROTO); 133 static int sysctl_kern_lwp(SYSCTLFN_PROTO); 134 static int sysctl_kern_forkfsleep(SYSCTLFN_PROTO); 135 static int sysctl_kern_somaxkva(SYSCTLFN_PROTO); 136 static int sysctl_kern_root_partition(SYSCTLFN_PROTO); 137 static int sysctl_kern_drivers(SYSCTLFN_PROTO); 138 static int sysctl_doeproc(SYSCTLFN_PROTO); 139 static int sysctl_kern_proc_args(SYSCTLFN_PROTO); 140 static int sysctl_hw_usermem(SYSCTLFN_PROTO); 141 static int sysctl_hw_cnmagic(SYSCTLFN_PROTO); 142 static int sysctl_hw_ncpu(SYSCTLFN_PROTO); 143 144 static void fill_kproc2(struct proc *, struct kinfo_proc2 *); 145 static void fill_lwp(struct lwp *l, struct kinfo_lwp *kl); 146 147 /* 148 * ******************************************************************** 149 * section 1: setup routines 150 * ******************************************************************** 151 * these functions are stuffed into a link set for sysctl setup 152 * functions. they're never called or referenced from anywhere else. 153 * ******************************************************************** 154 */ 155 156 /* 157 * sets up the base nodes... 158 */ 159 SYSCTL_SETUP(sysctl_root_setup, "sysctl base setup") 160 { 161 162 sysctl_createv(SYSCTL_PERMANENT, 163 CTLTYPE_NODE, "kern", NULL, 164 NULL, 0, NULL, 0, 165 CTL_KERN, CTL_EOL); 166 sysctl_createv(SYSCTL_PERMANENT, 167 CTLTYPE_NODE, "vm", NULL, 168 NULL, 0, NULL, 0, 169 CTL_VM, CTL_EOL); 170 sysctl_createv(SYSCTL_PERMANENT, 171 CTLTYPE_NODE, "vfs", NULL, 172 NULL, 0, NULL, 0, 173 CTL_VFS, CTL_EOL); 174 sysctl_createv(SYSCTL_PERMANENT, 175 CTLTYPE_NODE, "net", NULL, 176 NULL, 0, NULL, 0, 177 CTL_NET, CTL_EOL); 178 sysctl_createv(SYSCTL_PERMANENT, 179 CTLTYPE_NODE, "debug", NULL, 180 NULL, 0, NULL, 0, 181 CTL_DEBUG, CTL_EOL); 182 sysctl_createv(SYSCTL_PERMANENT, 183 CTLTYPE_NODE, "hw", NULL, 184 NULL, 0, NULL, 0, 185 CTL_HW, CTL_EOL); 186 sysctl_createv(SYSCTL_PERMANENT, 187 CTLTYPE_NODE, "machdep", NULL, 188 NULL, 0, NULL, 0, 189 CTL_MACHDEP, CTL_EOL); 190 /* 191 * this node is inserted so that the sysctl nodes in libc can 192 * operate. 193 */ 194 sysctl_createv(SYSCTL_PERMANENT, 195 CTLTYPE_NODE, "user", NULL, 196 NULL, 0, NULL, 0, 197 CTL_USER, CTL_EOL); 198 sysctl_createv(SYSCTL_PERMANENT, 199 CTLTYPE_NODE, "ddb", NULL, 200 NULL, 0, NULL, 0, 201 CTL_DDB, CTL_EOL); 202 sysctl_createv(SYSCTL_PERMANENT, 203 CTLTYPE_NODE, "proc", NULL, 204 NULL, 0, NULL, 0, 205 CTL_PROC, CTL_EOL); 206 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 207 CTLTYPE_NODE, "vendor", NULL, 208 NULL, 0, NULL, 0, 209 CTL_VENDOR, CTL_EOL); 210 sysctl_createv(SYSCTL_PERMANENT, 211 CTLTYPE_NODE, "emul", NULL, 212 NULL, 0, NULL, 0, 213 CTL_EMUL, CTL_EOL); 214 } 215 216 /* 217 * this setup routine is a replacement for kern_sysctl() 218 */ 219 SYSCTL_SETUP(sysctl_kern_setup, "sysctl kern subtree setup") 220 { 221 extern int kern_logsigexit; /* defined in kern/kern_sig.c */ 222 extern fixpt_t ccpu; /* defined in kern/kern_synch.c */ 223 extern int dumponpanic; /* defined in kern/subr_prf.c */ 224 225 sysctl_createv(SYSCTL_PERMANENT, 226 CTLTYPE_NODE, "kern", NULL, 227 NULL, 0, NULL, 0, 228 CTL_KERN, CTL_EOL); 229 230 sysctl_createv(SYSCTL_PERMANENT, 231 CTLTYPE_STRING, "ostype", NULL, 232 NULL, 0, &ostype, 0, 233 CTL_KERN, KERN_OSTYPE, CTL_EOL); 234 sysctl_createv(SYSCTL_PERMANENT, 235 CTLTYPE_STRING, "osrelease", NULL, 236 NULL, 0, &osrelease, 0, 237 CTL_KERN, KERN_OSRELEASE, CTL_EOL); 238 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 239 CTLTYPE_INT, "osrevision", NULL, 240 NULL, __NetBSD_Version__, NULL, 0, 241 CTL_KERN, KERN_OSREV, CTL_EOL); 242 sysctl_createv(SYSCTL_PERMANENT, 243 CTLTYPE_STRING, "version", NULL, 244 NULL, 0, &version, 0, 245 CTL_KERN, KERN_VERSION, CTL_EOL); 246 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 247 CTLTYPE_INT, "maxvnodes", NULL, 248 sysctl_kern_maxvnodes, 0, NULL, 0, 249 CTL_KERN, KERN_MAXVNODES, CTL_EOL); 250 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 251 CTLTYPE_INT, "maxproc", NULL, 252 sysctl_kern_maxproc, 0, NULL, 0, 253 CTL_KERN, KERN_MAXPROC, CTL_EOL); 254 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 255 CTLTYPE_INT, "maxfiles", NULL, 256 NULL, 0, &maxfiles, 0, 257 CTL_KERN, KERN_MAXFILES, CTL_EOL); 258 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 259 CTLTYPE_INT, "argmax", NULL, 260 NULL, ARG_MAX, NULL, 0, 261 CTL_KERN, KERN_ARGMAX, CTL_EOL); 262 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 263 CTLTYPE_INT, "securelevel", NULL, 264 sysctl_kern_securelevel, 0, &securelevel, 0, 265 CTL_KERN, KERN_SECURELVL, CTL_EOL); 266 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 267 CTLTYPE_STRING, "hostname", NULL, 268 sysctl_setlen, 0, &hostname, MAXHOSTNAMELEN, 269 CTL_KERN, KERN_HOSTNAME, CTL_EOL); 270 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 271 CTLTYPE_INT, "hostid", NULL, 272 sysctl_kern_hostid, 0, NULL, 0, 273 CTL_KERN, KERN_HOSTID, CTL_EOL); 274 sysctl_createv(SYSCTL_PERMANENT, 275 CTLTYPE_STRUCT, "clockrate", NULL, 276 sysctl_kern_clockrate, 0, NULL, 277 sizeof(struct clockinfo), 278 CTL_KERN, KERN_CLOCKRATE, CTL_EOL); 279 sysctl_createv(SYSCTL_PERMANENT, 280 CTLTYPE_STRUCT, "vnode", NULL, 281 sysctl_kern_vnode, 0, NULL, 0, 282 CTL_KERN, KERN_VNODE, CTL_EOL); 283 sysctl_createv(SYSCTL_PERMANENT, 284 CTLTYPE_STRUCT, "file", NULL, 285 sysctl_kern_file, 0, NULL, 0, 286 CTL_KERN, KERN_FILE, CTL_EOL); 287 #ifndef GPROF 288 sysctl_createv(SYSCTL_PERMANENT, 289 CTLTYPE_NODE, "profiling", NULL, 290 sysctl_notavail, 0, NULL, 0, 291 CTL_KERN, KERN_PROF, CTL_EOL); 292 #endif 293 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 294 CTLTYPE_INT, "posix1version", NULL, 295 NULL, _POSIX_VERSION, NULL, 0, 296 CTL_KERN, KERN_POSIX1, CTL_EOL); 297 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 298 CTLTYPE_INT, "ngroups", NULL, 299 NULL, NGROUPS_MAX, NULL, 0, 300 CTL_KERN, KERN_NGROUPS, CTL_EOL); 301 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 302 CTLTYPE_INT, "job_control", NULL, 303 NULL, 1, NULL, 0, 304 CTL_KERN, KERN_JOB_CONTROL, CTL_EOL); 305 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 306 CTLTYPE_INT, "saved_ids", NULL, NULL, 307 #ifdef _POSIX_SAVED_IDS 308 1, 309 #else /* _POSIX_SAVED_IDS */ 310 0, 311 #endif /* _POSIX_SAVED_IDS */ 312 NULL, 0, CTL_KERN, KERN_SAVED_IDS, CTL_EOL); 313 sysctl_createv(SYSCTL_PERMANENT, 314 CTLTYPE_STRUCT, "boottime", NULL, 315 NULL, 0, &boottime, sizeof(boottime), 316 CTL_KERN, KERN_BOOTTIME, CTL_EOL); 317 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 318 CTLTYPE_STRING, "domainname", NULL, 319 sysctl_setlen, 0, &domainname, MAXHOSTNAMELEN, 320 CTL_KERN, KERN_DOMAINNAME, CTL_EOL); 321 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 322 CTLTYPE_INT, "maxpartitions", NULL, 323 NULL, MAXPARTITIONS, NULL, 0, 324 CTL_KERN, KERN_MAXPARTITIONS, CTL_EOL); 325 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 326 CTLTYPE_INT, "rawpartition", NULL, 327 NULL, RAW_PART, NULL, 0, 328 CTL_KERN, KERN_RAWPARTITION, CTL_EOL); 329 sysctl_createv(SYSCTL_PERMANENT, 330 CTLTYPE_STRUCT, "timex", NULL, 331 sysctl_notavail, 0, NULL, 0, 332 CTL_KERN, KERN_TIMEX, CTL_EOL); 333 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 334 CTLTYPE_INT, "autonicetime", NULL, 335 sysctl_kern_autonice, 0, &autonicetime, 0, 336 CTL_KERN, KERN_AUTONICETIME, CTL_EOL); 337 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 338 CTLTYPE_INT, "autoniceval", NULL, 339 sysctl_kern_autonice, 0, &autoniceval, 0, 340 CTL_KERN, KERN_AUTONICEVAL, CTL_EOL); 341 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 342 CTLTYPE_INT, "rtc_offset", NULL, 343 sysctl_kern_rtc_offset, 0, &rtc_offset, 0, 344 CTL_KERN, KERN_RTC_OFFSET, CTL_EOL); 345 sysctl_createv(SYSCTL_PERMANENT, 346 CTLTYPE_STRING, "root_device", NULL, 347 sysctl_root_device, 0, NULL, 0, 348 CTL_KERN, KERN_ROOT_DEVICE, CTL_EOL); 349 sysctl_createv(SYSCTL_PERMANENT, 350 CTLTYPE_INT, "msgbufsize", NULL, 351 sysctl_msgbuf, 0, &msgbufp->msg_bufs, 0, 352 CTL_KERN, KERN_MSGBUFSIZE, CTL_EOL); 353 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 354 CTLTYPE_INT, "fsync", NULL, 355 NULL, 1, NULL, 0, 356 CTL_KERN, KERN_FSYNC, CTL_EOL); 357 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 358 CTLTYPE_INT, "sysvmsg", NULL, NULL, 359 #ifdef SYSVMSG 360 1, 361 #else /* SYSVMSG */ 362 0, 363 #endif /* SYSVMSG */ 364 NULL, 0, CTL_KERN, KERN_SYSVMSG, CTL_EOL); 365 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 366 CTLTYPE_INT, "sysvsem", NULL, NULL, 367 #ifdef SYSVSEM 368 1, 369 #else /* SYSVSEM */ 370 0, 371 #endif /* SYSVSEM */ 372 NULL, 0, CTL_KERN, KERN_SYSVSEM, CTL_EOL); 373 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 374 CTLTYPE_INT, "sysvshm", NULL, NULL, 375 #ifdef SYSVSHM 376 1, 377 #else /* SYSVSHM */ 378 0, 379 #endif /* SYSVSHM */ 380 NULL, 0, CTL_KERN, KERN_SYSVSHM, CTL_EOL); 381 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 382 CTLTYPE_INT, "synchronized_io", NULL, 383 NULL, 1, NULL, 0, 384 CTL_KERN, KERN_SYNCHRONIZED_IO, CTL_EOL); 385 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 386 CTLTYPE_INT, "iov_max", NULL, 387 NULL, IOV_MAX, NULL, 0, 388 CTL_KERN, KERN_IOV_MAX, CTL_EOL); 389 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 390 CTLTYPE_INT, "mapped_files", NULL, 391 NULL, 1, NULL, 0, 392 CTL_KERN, KERN_MAPPED_FILES, CTL_EOL); 393 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 394 CTLTYPE_INT, "memlock", NULL, 395 NULL, 1, NULL, 0, 396 CTL_KERN, KERN_MEMLOCK, CTL_EOL); 397 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 398 CTLTYPE_INT, "memlock_range", NULL, 399 NULL, 1, NULL, 0, 400 CTL_KERN, KERN_MEMLOCK_RANGE, CTL_EOL); 401 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 402 CTLTYPE_INT, "memory_protection", NULL, 403 NULL, 1, NULL, 0, 404 CTL_KERN, KERN_MEMORY_PROTECTION, CTL_EOL); 405 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 406 CTLTYPE_INT, "login_name_max", NULL, 407 NULL, LOGIN_NAME_MAX, NULL, 0, 408 CTL_KERN, KERN_LOGIN_NAME_MAX, CTL_EOL); 409 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 410 CTLTYPE_STRING, "defcorename", NULL, 411 sysctl_kern_defcorename, 0, defcorename, MAXPATHLEN, 412 CTL_KERN, KERN_DEFCORENAME, CTL_EOL); 413 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 414 CTLTYPE_INT, "logsigexit", NULL, 415 NULL, 0, &kern_logsigexit, 0, 416 CTL_KERN, KERN_LOGSIGEXIT, CTL_EOL); 417 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 418 CTLTYPE_INT, "fscale", NULL, 419 NULL, FSCALE, NULL, 0, 420 CTL_KERN, KERN_FSCALE, CTL_EOL); 421 sysctl_createv(SYSCTL_PERMANENT, 422 CTLTYPE_INT, "ccpu", NULL, 423 NULL, 0, &ccpu, 0, 424 CTL_KERN, KERN_CCPU, CTL_EOL); 425 sysctl_createv(SYSCTL_PERMANENT, 426 CTLTYPE_STRUCT, "cp_time", NULL, 427 sysctl_kern_cptime, 0, NULL, 0, 428 CTL_KERN, KERN_CP_TIME, CTL_EOL); 429 #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) 430 sysctl_createv(SYSCTL_PERMANENT, 431 CTLTYPE_STRUCT, "sysvipc_info", NULL, 432 sysctl_kern_sysvipc, 0, NULL, 0, 433 CTL_KERN, KERN_SYSVIPC_INFO, CTL_EOL); 434 #endif /* SYSVMSG || SYSVSEM || SYSVSHM */ 435 sysctl_createv(SYSCTL_PERMANENT, 436 CTLTYPE_INT, "msgbuf", NULL, 437 sysctl_msgbuf, 0, NULL, 0, 438 CTL_KERN, KERN_MSGBUF, CTL_EOL); 439 sysctl_createv(SYSCTL_PERMANENT, 440 CTLTYPE_STRUCT, "consdev", NULL, 441 sysctl_consdev, 0, NULL, sizeof(dev_t), 442 CTL_KERN, KERN_CONSDEV, CTL_EOL); 443 #if NPTY > 0 444 sysctl_createv(SYSCTL_PERMANENT, 445 CTLTYPE_INT, "maxptys", NULL, 446 sysctl_kern_maxptys, 0, NULL, 0, 447 CTL_KERN, KERN_MAXPTYS, CTL_EOL); 448 #endif /* NPTY > 0 */ 449 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 450 CTLTYPE_INT, "maxphys", NULL, 451 NULL, MAXPHYS, NULL, 0, 452 CTL_KERN, KERN_MAXPHYS, CTL_EOL); 453 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 454 CTLTYPE_INT, "sbmax", NULL, 455 sysctl_kern_sbmax, 0, NULL, 0, 456 CTL_KERN, KERN_SBMAX, CTL_EOL); 457 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 458 CTLTYPE_INT, "monotonic_clock", NULL, 459 /* XXX _POSIX_VERSION */ 460 NULL, _POSIX_MONOTONIC_CLOCK, NULL, 0, 461 CTL_KERN, KERN_MONOTONIC_CLOCK, CTL_EOL); 462 sysctl_createv(SYSCTL_PERMANENT, 463 CTLTYPE_INT, "urandom", NULL, 464 sysctl_kern_urnd, 0, NULL, 0, 465 CTL_KERN, KERN_URND, CTL_EOL); 466 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 467 CTLTYPE_INT, "labelsector", NULL, 468 NULL, LABELSECTOR, NULL, 0, 469 CTL_KERN, KERN_LABELSECTOR, CTL_EOL); 470 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 471 CTLTYPE_INT, "labeloffset", NULL, 472 NULL, LABELOFFSET, NULL, 0, 473 CTL_KERN, KERN_LABELOFFSET, CTL_EOL); 474 sysctl_createv(SYSCTL_PERMANENT, 475 CTLTYPE_NODE, "lwp", NULL, 476 sysctl_kern_lwp, 0, NULL, 0, 477 CTL_KERN, KERN_LWP, CTL_EOL); 478 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 479 CTLTYPE_INT, "forkfsleep", NULL, 480 sysctl_kern_forkfsleep, 0, NULL, 0, 481 CTL_KERN, KERN_FORKFSLEEP, CTL_EOL); 482 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 483 CTLTYPE_INT, "posix_threads", NULL, 484 /* XXX _POSIX_VERSION */ 485 NULL, _POSIX_THREADS, NULL, 0, 486 CTL_KERN, KERN_POSIX_THREADS, CTL_EOL); 487 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 488 CTLTYPE_INT, "posix_semaphores", NULL, NULL, 489 #ifdef P1003_1B_SEMAPHORE 490 200112, 491 #else /* P1003_1B_SEMAPHORE */ 492 0, 493 #endif /* P1003_1B_SEMAPHORE */ 494 NULL, 0, CTL_KERN, KERN_POSIX_SEMAPHORES, CTL_EOL); 495 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 496 CTLTYPE_INT, "posix_barriers", NULL, 497 /* XXX _POSIX_VERSION */ 498 NULL, _POSIX_BARRIERS, NULL, 0, 499 CTL_KERN, KERN_POSIX_BARRIERS, CTL_EOL); 500 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 501 CTLTYPE_INT, "posix_timers", NULL, 502 /* XXX _POSIX_VERSION */ 503 NULL, _POSIX_TIMERS, NULL, 0, 504 CTL_KERN, KERN_POSIX_TIMERS, CTL_EOL); 505 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 506 CTLTYPE_INT, "posix_spin_locks", NULL, 507 /* XXX _POSIX_VERSION */ 508 NULL, _POSIX_SPIN_LOCKS, NULL, 0, 509 CTL_KERN, KERN_POSIX_SPIN_LOCKS, CTL_EOL); 510 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 511 CTLTYPE_INT, "posix_reader_writer_locks", NULL, 512 /* XXX _POSIX_VERSION */ 513 NULL, _POSIX_READER_WRITER_LOCKS, NULL, 0, 514 CTL_KERN, KERN_POSIX_READER_WRITER_LOCKS, CTL_EOL); 515 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 516 CTLTYPE_INT, "dump_on_panic", NULL, 517 NULL, 0, &dumponpanic, 0, 518 CTL_KERN, KERN_DUMP_ON_PANIC, CTL_EOL); 519 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, 520 CTLTYPE_INT, "somaxkva", NULL, 521 sysctl_kern_somaxkva, 0, NULL, 0, 522 CTL_KERN, KERN_SOMAXKVA, CTL_EOL); 523 sysctl_createv(SYSCTL_PERMANENT, 524 CTLTYPE_INT, "root_partition", NULL, 525 sysctl_kern_root_partition, 0, NULL, 0, 526 CTL_KERN, KERN_ROOT_PARTITION, CTL_EOL); 527 sysctl_createv(SYSCTL_PERMANENT, 528 CTLTYPE_STRUCT, "drivers", NULL, 529 sysctl_kern_drivers, 0, NULL, 0, 530 CTL_KERN, KERN_DRIVERS, CTL_EOL); 531 } 532 533 SYSCTL_SETUP(sysctl_kern_proc_setup, 534 "sysctl kern.proc/proc2/proc_args subtree setup") 535 { 536 537 sysctl_createv(SYSCTL_PERMANENT, 538 CTLTYPE_NODE, "kern", NULL, 539 NULL, 0, NULL, 0, 540 CTL_KERN, CTL_EOL); 541 542 sysctl_createv(SYSCTL_PERMANENT, 543 CTLTYPE_NODE, "proc", NULL, 544 sysctl_doeproc, 0, NULL, 0, 545 CTL_KERN, KERN_PROC, CTL_EOL); 546 sysctl_createv(SYSCTL_PERMANENT, 547 CTLTYPE_NODE, "proc2", NULL, 548 sysctl_doeproc, 0, NULL, 0, 549 CTL_KERN, KERN_PROC2, CTL_EOL); 550 sysctl_createv(SYSCTL_PERMANENT, 551 CTLTYPE_NODE, "proc_args", NULL, 552 sysctl_kern_proc_args, 0, NULL, 0, 553 CTL_KERN, KERN_PROC_ARGS, CTL_EOL); 554 555 /* 556 "nodes" under these: 557 558 KERN_PROC_ALL 559 KERN_PROC_PID pid 560 KERN_PROC_PGRP pgrp 561 KERN_PROC_SESSION sess 562 KERN_PROC_TTY tty 563 KERN_PROC_UID uid 564 KERN_PROC_RUID uid 565 KERN_PROC_GID gid 566 KERN_PROC_RGID gid 567 568 all in all, probably not worth the effort... 569 */ 570 } 571 572 SYSCTL_SETUP(sysctl_hw_setup, "sysctl hw subtree setup") 573 { 574 u_int u; 575 u_quad_t q; 576 577 sysctl_createv(SYSCTL_PERMANENT, 578 CTLTYPE_NODE, "hw", NULL, 579 NULL, 0, NULL, 0, 580 CTL_HW, CTL_EOL); 581 582 sysctl_createv(SYSCTL_PERMANENT, 583 CTLTYPE_STRING, "machine", NULL, 584 NULL, 0, machine, 0, 585 CTL_HW, HW_MACHINE, CTL_EOL); 586 sysctl_createv(SYSCTL_PERMANENT, 587 CTLTYPE_STRING, "model", NULL, 588 NULL, 0, cpu_model, 0, 589 CTL_HW, HW_MODEL, CTL_EOL); 590 sysctl_createv(SYSCTL_PERMANENT, 591 CTLTYPE_INT, "ncpu", NULL, 592 sysctl_hw_ncpu, 0, NULL, 0, 593 CTL_HW, HW_NCPU, CTL_EOL); 594 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 595 CTLTYPE_INT, "byteorder", NULL, 596 NULL, BYTE_ORDER, NULL, 0, 597 CTL_HW, HW_BYTEORDER, CTL_EOL); 598 u = ((u_int)physmem > (UINT_MAX / PAGE_SIZE)) ? 599 UINT_MAX : physmem * PAGE_SIZE; 600 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 601 CTLTYPE_INT, "physmem", NULL, 602 NULL, u, NULL, 0, 603 CTL_HW, HW_PHYSMEM, CTL_EOL); 604 sysctl_createv(SYSCTL_PERMANENT, 605 CTLTYPE_INT, "usermem", NULL, 606 sysctl_hw_usermem, 0, NULL, 0, 607 CTL_HW, HW_USERMEM, CTL_EOL); 608 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 609 CTLTYPE_INT, "pagesize", NULL, 610 NULL, PAGE_SIZE, NULL, 0, 611 CTL_HW, HW_PAGESIZE, CTL_EOL); 612 sysctl_createv(SYSCTL_PERMANENT, 613 CTLTYPE_STRING, "disknames", NULL, 614 sysctl_hw_disknames, 0, NULL, 0, 615 CTL_HW, HW_DISKNAMES, CTL_EOL); 616 sysctl_createv(SYSCTL_PERMANENT, 617 CTLTYPE_STRUCT, "diskstats", NULL, 618 sysctl_hw_diskstats, 0, NULL, 0, 619 CTL_HW, HW_DISKSTATS, CTL_EOL); 620 sysctl_createv(SYSCTL_PERMANENT, 621 CTLTYPE_STRING, "machine_arch", NULL, 622 NULL, 0, machine_arch, 0, 623 CTL_HW, HW_MACHINE_ARCH, CTL_EOL); 624 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 625 CTLTYPE_INT, "alignbytes", NULL, 626 NULL, ALIGNBYTES, NULL, 0, 627 CTL_HW, HW_ALIGNBYTES, CTL_EOL); 628 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE|SYSCTL_HEX, 629 CTLTYPE_STRING, "cnmagic", NULL, 630 sysctl_hw_cnmagic, 0, NULL, CNS_LEN, 631 CTL_HW, HW_CNMAGIC, CTL_EOL); 632 q = (u_quad_t)physmem * PAGE_SIZE; 633 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_IMMEDIATE, 634 CTLTYPE_QUAD, "physmem64", NULL, 635 NULL, q, NULL, 0, 636 CTL_HW, HW_PHYSMEM64, CTL_EOL); 637 sysctl_createv(SYSCTL_PERMANENT, 638 CTLTYPE_QUAD, "usermem64", NULL, 639 sysctl_hw_usermem, 0, NULL, 0, 640 CTL_HW, HW_USERMEM64, CTL_EOL); 641 } 642 643 #ifdef DEBUG 644 /* 645 * Debugging related system variables. 646 */ 647 struct ctldebug /* debug0, */ /* debug1, */ debug2, debug3, debug4; 648 struct ctldebug debug5, debug6, debug7, debug8, debug9; 649 struct ctldebug debug10, debug11, debug12, debug13, debug14; 650 struct ctldebug debug15, debug16, debug17, debug18, debug19; 651 static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = { 652 &debug0, &debug1, &debug2, &debug3, &debug4, 653 &debug5, &debug6, &debug7, &debug8, &debug9, 654 &debug10, &debug11, &debug12, &debug13, &debug14, 655 &debug15, &debug16, &debug17, &debug18, &debug19, 656 }; 657 658 /* 659 * this setup routine is a replacement for debug_sysctl() 660 * 661 * note that it creates several nodes per defined debug variable 662 */ 663 SYSCTL_SETUP(sysctl_debug_setup, "sysctl debug subtree setup") 664 { 665 struct ctldebug *cdp; 666 char nodename[20]; 667 int i; 668 669 /* 670 * two ways here: 671 * 672 * the "old" way (debug.name -> value) which was emulated by 673 * the sysctl(8) binary 674 * 675 * the new way, which the sysctl(8) binary was actually using 676 677 node debug 678 node debug.0 679 string debug.0.name 680 int debug.0.value 681 int debug.name 682 683 */ 684 685 sysctl_createv(SYSCTL_PERMANENT, 686 CTLTYPE_NODE, "debug", NULL, 687 NULL, 0, NULL, 0, 688 CTL_DEBUG, CTL_EOL); 689 690 for (i = 0; i < CTL_DEBUG_MAXID; i++) { 691 cdp = debugvars[i]; 692 if (cdp->debugname == NULL || cdp->debugvar == NULL) 693 continue; 694 695 snprintf(nodename, sizeof(nodename), "debug%d", i); 696 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_HIDDEN, 697 CTLTYPE_NODE, nodename, NULL, 698 NULL, 0, NULL, 0, 699 CTL_DEBUG, i, CTL_EOL); 700 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_HIDDEN, 701 CTLTYPE_STRING, "name", NULL, 702 NULL, 0, cdp->debugname, 0, 703 CTL_DEBUG, i, CTL_DEBUG_NAME, CTL_EOL); 704 sysctl_createv(SYSCTL_PERMANENT|SYSCTL_HIDDEN, 705 CTLTYPE_INT, "value", NULL, 706 NULL, 0, cdp->debugvar, 0, 707 CTL_DEBUG, i, CTL_DEBUG_VALUE, CTL_EOL); 708 sysctl_createv(SYSCTL_PERMANENT, 709 CTLTYPE_INT, cdp->debugname, NULL, 710 NULL, 0, cdp->debugvar, 0, 711 CTL_DEBUG, CTL_CREATE, CTL_EOL); 712 } 713 } 714 #endif /* DEBUG */ 715 716 /* 717 * ******************************************************************** 718 * section 2: private node-specific helper routines. 719 * ******************************************************************** 720 */ 721 722 /* 723 * sysctl helper routine for kern.maxvnodes. drain vnodes if 724 * new value is lower than desiredvnodes and then calls reinit 725 * routines that needs to adjust to the new value. 726 */ 727 static int 728 sysctl_kern_maxvnodes(SYSCTLFN_ARGS) 729 { 730 int error, new_vnodes, old_vnodes; 731 struct sysctlnode node; 732 733 new_vnodes = desiredvnodes; 734 node = *rnode; 735 node.sysctl_data = &new_vnodes; 736 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 737 if (error || newp == NULL) 738 return (error); 739 740 old_vnodes = desiredvnodes; 741 desiredvnodes = new_vnodes; 742 if (new_vnodes < old_vnodes) { 743 error = vfs_drainvnodes(new_vnodes, l->l_proc); 744 if (error) { 745 desiredvnodes = old_vnodes; 746 return (error); 747 } 748 } 749 vfs_reinit(); 750 nchreinit(); 751 752 return (0); 753 } 754 755 /* 756 * sysctl helper routine for rtc_offset - set time after changes 757 */ 758 static int 759 sysctl_kern_rtc_offset(SYSCTLFN_ARGS) 760 { 761 struct timeval tv, delta; 762 int s, error, new_rtc_offset; 763 struct sysctlnode node; 764 765 new_rtc_offset = rtc_offset; 766 node = *rnode; 767 node.sysctl_data = &new_rtc_offset; 768 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 769 if (error || newp == NULL) 770 return (error); 771 772 if (securelevel > 0) 773 return (EPERM); 774 if (rtc_offset == new_rtc_offset) 775 return (0); 776 777 /* if we change the offset, adjust the time */ 778 s = splclock(); 779 tv = time; 780 splx(s); 781 delta.tv_sec = 60*(new_rtc_offset - rtc_offset); 782 delta.tv_usec = 0; 783 timeradd(&tv, &delta, &tv); 784 rtc_offset = new_rtc_offset; 785 settime(&tv); 786 787 return (0); 788 } 789 790 /* 791 * sysctl helper routine for kern.maxvnodes. ensures that the new 792 * values are not too low or too high. 793 */ 794 static int 795 sysctl_kern_maxproc(SYSCTLFN_ARGS) 796 { 797 int error, nmaxproc; 798 struct sysctlnode node; 799 800 nmaxproc = maxproc; 801 node = *rnode; 802 node.sysctl_data = &nmaxproc; 803 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 804 if (error || newp == NULL) 805 return (error); 806 807 if (nmaxproc < 0 || nmaxproc >= PID_MAX) 808 return (EINVAL); 809 #ifdef __HAVE_CPU_MAXPROC 810 if (nmaxproc > cpu_maxproc()) 811 return (EINVAL); 812 #endif 813 maxproc = nmaxproc; 814 815 return (0); 816 } 817 818 /* 819 * sysctl helper routine for kern.securelevel. ensures that the value 820 * only rises unless the caller has pid 1 (assumed to be init). 821 */ 822 static int 823 sysctl_kern_securelevel(SYSCTLFN_ARGS) 824 { 825 int newsecurelevel, error; 826 struct sysctlnode node; 827 828 newsecurelevel = securelevel; 829 node = *rnode; 830 node.sysctl_data = &newsecurelevel; 831 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 832 if (error || newp == NULL) 833 return (error); 834 835 if (newsecurelevel < securelevel && l && l->l_proc->p_pid != 1) 836 return (EPERM); 837 securelevel = newsecurelevel; 838 839 return (error); 840 } 841 842 /* 843 * sysctl helper function for kern.hostid. the hostid is a long, but 844 * we export it as an int, so we need to give it a little help. 845 */ 846 static int 847 sysctl_kern_hostid(SYSCTLFN_ARGS) 848 { 849 int error, inthostid; 850 struct sysctlnode node; 851 852 inthostid = hostid; /* XXX assumes sizeof int >= sizeof long */ 853 node = *rnode; 854 node.sysctl_data = &inthostid; 855 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 856 if (error || newp == NULL) 857 return (error); 858 859 hostid = inthostid; 860 861 return (0); 862 } 863 864 /* 865 * sysctl helper function for kern.hostname and kern.domainnname. 866 * resets the relevant recorded length when the underlying name is 867 * changed. 868 */ 869 static int 870 sysctl_setlen(SYSCTLFN_ARGS) 871 { 872 int error; 873 874 error = sysctl_lookup(SYSCTLFN_CALL(rnode)); 875 if (error || newp == NULL) 876 return (error); 877 878 switch (rnode->sysctl_num) { 879 case KERN_HOSTNAME: 880 hostnamelen = strlen((const char*)rnode->sysctl_data); 881 break; 882 case KERN_DOMAINNAME: 883 domainnamelen = strlen((const char*)rnode->sysctl_data); 884 break; 885 } 886 887 return (0); 888 } 889 890 /* 891 * sysctl helper routine for kern.clockrate. assembles a struct on 892 * the fly to be returned to the caller. 893 */ 894 static int 895 sysctl_kern_clockrate(SYSCTLFN_ARGS) 896 { 897 struct clockinfo clkinfo; 898 struct sysctlnode node; 899 900 clkinfo.tick = tick; 901 clkinfo.tickadj = tickadj; 902 clkinfo.hz = hz; 903 clkinfo.profhz = profhz; 904 clkinfo.stathz = stathz ? stathz : hz; 905 906 node = *rnode; 907 node.sysctl_data = &clkinfo; 908 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 909 } 910 911 912 /* 913 * sysctl helper routine for kern.file pseudo-subtree. 914 */ 915 static int 916 sysctl_kern_file(SYSCTLFN_ARGS) 917 { 918 int error; 919 size_t buflen; 920 struct file *fp; 921 char *start, *where; 922 923 start = where = oldp; 924 buflen = *oldlenp; 925 if (where == NULL) { 926 /* 927 * overestimate by 10 files 928 */ 929 *oldlenp = sizeof(filehead) + (nfiles + 10) * sizeof(struct file); 930 return (0); 931 } 932 933 /* 934 * first copyout filehead 935 */ 936 if (buflen < sizeof(filehead)) { 937 *oldlenp = 0; 938 return (0); 939 } 940 error = copyout(&filehead, where, sizeof(filehead)); 941 if (error) 942 return (error); 943 buflen -= sizeof(filehead); 944 where += sizeof(filehead); 945 946 /* 947 * followed by an array of file structures 948 */ 949 LIST_FOREACH(fp, &filehead, f_list) { 950 if (buflen < sizeof(struct file)) { 951 *oldlenp = where - start; 952 return (ENOMEM); 953 } 954 error = copyout(fp, where, sizeof(struct file)); 955 if (error) 956 return (error); 957 buflen -= sizeof(struct file); 958 where += sizeof(struct file); 959 } 960 *oldlenp = where - start; 961 return (0); 962 } 963 964 /* 965 * sysctl helper routine for kern.autonicetime and kern.autoniceval. 966 * asserts that the assigned value is in the correct range. 967 */ 968 static int 969 sysctl_kern_autonice(SYSCTLFN_ARGS) 970 { 971 int error, t = 0; 972 struct sysctlnode node; 973 974 node = *rnode; 975 t = *(int*)node.sysctl_data; 976 node.sysctl_data = &t; 977 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 978 if (error || newp == NULL) 979 return (error); 980 981 switch (node.sysctl_num) { 982 case KERN_AUTONICETIME: 983 if (t >= 0) 984 autonicetime = t; 985 break; 986 case KERN_AUTONICEVAL: 987 if (t < PRIO_MIN) 988 t = PRIO_MIN; 989 else if (t > PRIO_MAX) 990 t = PRIO_MAX; 991 autoniceval = t; 992 break; 993 } 994 995 return (0); 996 } 997 998 /* 999 * sysctl helper routine for kern.msgbufsize and kern.msgbuf. for the 1000 * former it merely checks the the message buffer is set up. for the 1001 * latter, it also copies out the data if necessary. 1002 */ 1003 static int 1004 sysctl_msgbuf(SYSCTLFN_ARGS) 1005 { 1006 char *where = oldp; 1007 size_t len, maxlen; 1008 long beg, end; 1009 int error; 1010 1011 if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) { 1012 msgbufenabled = 0; 1013 return (ENXIO); 1014 } 1015 1016 switch (rnode->sysctl_num) { 1017 case KERN_MSGBUFSIZE: 1018 return (sysctl_lookup(SYSCTLFN_CALL(rnode))); 1019 case KERN_MSGBUF: 1020 break; 1021 default: 1022 return (EOPNOTSUPP); 1023 } 1024 1025 if (newp != NULL) 1026 return (EPERM); 1027 1028 if (oldp == NULL) { 1029 /* always return full buffer size */ 1030 *oldlenp = msgbufp->msg_bufs; 1031 return (0); 1032 } 1033 1034 error = 0; 1035 maxlen = MIN(msgbufp->msg_bufs, *oldlenp); 1036 1037 /* 1038 * First, copy from the write pointer to the end of 1039 * message buffer. 1040 */ 1041 beg = msgbufp->msg_bufx; 1042 end = msgbufp->msg_bufs; 1043 while (maxlen > 0) { 1044 len = MIN(end - beg, maxlen); 1045 if (len == 0) 1046 break; 1047 error = copyout(&msgbufp->msg_bufc[beg], where, len); 1048 if (error) 1049 break; 1050 where += len; 1051 maxlen -= len; 1052 1053 /* 1054 * ... then, copy from the beginning of message buffer to 1055 * the write pointer. 1056 */ 1057 beg = 0; 1058 end = msgbufp->msg_bufx; 1059 } 1060 1061 return (error); 1062 } 1063 1064 /* 1065 * sysctl helper routine for kern.defcorename. in the case of a new 1066 * string being assigned, check that it's not a zero-length string. 1067 * (XXX the check in -current doesn't work, but do we really care?) 1068 */ 1069 static int 1070 sysctl_kern_defcorename(SYSCTLFN_ARGS) 1071 { 1072 int error; 1073 char newcorename[MAXPATHLEN]; 1074 struct sysctlnode node; 1075 1076 node = *rnode; 1077 node.sysctl_data = &newcorename[0]; 1078 memcpy(node.sysctl_data, rnode->sysctl_data, MAXPATHLEN); 1079 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1080 if (error || newp == NULL) 1081 return (error); 1082 1083 /* 1084 * when sysctl_lookup() deals with a string, it's guaranteed 1085 * to come back nul terminated. so there. :) 1086 */ 1087 if (strlen(newcorename) == 0) 1088 return (EINVAL); 1089 1090 memcpy(rnode->sysctl_data, node.sysctl_data, MAXPATHLEN); 1091 1092 return (0); 1093 } 1094 1095 /* 1096 * sysctl helper routine for kern.cp_time node. adds up cpu time 1097 * across all cpus. 1098 */ 1099 static int 1100 sysctl_kern_cptime(SYSCTLFN_ARGS) 1101 { 1102 struct sysctlnode node = *rnode; 1103 1104 #ifndef MULTIPROCESSOR 1105 1106 if (namelen == 1) { 1107 if (name[0] != 0) 1108 return (ENOENT); 1109 /* 1110 * you're allowed to ask for the zero'th processor 1111 */ 1112 name++; 1113 namelen--; 1114 } 1115 node.sysctl_data = curcpu()->ci_schedstate.spc_cp_time; 1116 node.sysctl_size = sizeof(curcpu()->ci_schedstate.spc_cp_time); 1117 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 1118 1119 #else /* MULTIPROCESSOR */ 1120 1121 u_int64_t *cp_time = NULL; 1122 int error, n = sysctl_ncpus(), i; 1123 struct cpu_info *ci; 1124 CPU_INFO_ITERATOR cii; 1125 1126 /* 1127 * if you specifically pass a buffer that is the size of the 1128 * sum, or if you are probing for the size, you get the "sum" 1129 * of cp_time (and the size thereof) across all processors. 1130 * 1131 * alternately, you can pass an additional mib number and get 1132 * cp_time for that particular processor. 1133 */ 1134 switch (namelen) { 1135 case 0: 1136 if (*oldlenp == sizeof(u_int64_t) * CPUSTATES || oldp == NULL) { 1137 node.sysctl_size = sizeof(u_int64_t) * CPUSTATES; 1138 n = -1; /* SUM */ 1139 } 1140 else { 1141 node.sysctl_size = n * sizeof(u_int64_t) * CPUSTATES; 1142 n = -2; /* ALL */ 1143 } 1144 break; 1145 case 1: 1146 if (name[0] < 0 || name[0] >= n) 1147 return (ENOENT); /* ENOSUCHPROCESSOR */ 1148 node.sysctl_size = sizeof(u_int64_t) * CPUSTATES; 1149 n = name[0]; 1150 /* 1151 * adjust these so that sysctl_lookup() will be happy 1152 */ 1153 name++; 1154 namelen--; 1155 break; 1156 default: 1157 return (EINVAL); 1158 } 1159 1160 cp_time = malloc(node.sysctl_size, M_TEMP, M_WAITOK|M_CANFAIL); 1161 if (cp_time == NULL) 1162 return (ENOMEM); 1163 node.sysctl_data = cp_time; 1164 memset(cp_time, 0, node.sysctl_size); 1165 1166 for (CPU_INFO_FOREACH(cii, ci)) { 1167 if (n <= 0) 1168 for (i = 0; i < CPUSTATES; i++) 1169 cp_time[i] += ci->ci_schedstate.spc_cp_time[i]; 1170 /* 1171 * if a specific processor was requested and we just 1172 * did it, we're done here 1173 */ 1174 if (n == 0) 1175 break; 1176 /* 1177 * if doing "all", skip to next cp_time set for next processor 1178 */ 1179 if (n == -2) 1180 cp_time += CPUSTATES; 1181 /* 1182 * if we're doing a specific processor, we're one 1183 * processor closer 1184 */ 1185 if (n > 0) 1186 n--; 1187 } 1188 1189 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1190 free(node.sysctl_data, M_TEMP); 1191 return (error); 1192 1193 #endif /* MULTIPROCESSOR */ 1194 } 1195 1196 #if defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) 1197 /* 1198 * sysctl helper routine for kern.sysvipc_info subtree. 1199 */ 1200 1201 #define FILL_PERM(src, dst) do { \ 1202 (dst)._key = (src)._key; \ 1203 (dst).uid = (src).uid; \ 1204 (dst).gid = (src).gid; \ 1205 (dst).cuid = (src).cuid; \ 1206 (dst).cgid = (src).cgid; \ 1207 (dst).mode = (src).mode; \ 1208 (dst)._seq = (src)._seq; \ 1209 } while (/*CONSTCOND*/ 0); 1210 #define FILL_MSG(src, dst) do { \ 1211 FILL_PERM((src).msg_perm, (dst).msg_perm); \ 1212 (dst).msg_qnum = (src).msg_qnum; \ 1213 (dst).msg_qbytes = (src).msg_qbytes; \ 1214 (dst)._msg_cbytes = (src)._msg_cbytes; \ 1215 (dst).msg_lspid = (src).msg_lspid; \ 1216 (dst).msg_lrpid = (src).msg_lrpid; \ 1217 (dst).msg_stime = (src).msg_stime; \ 1218 (dst).msg_rtime = (src).msg_rtime; \ 1219 (dst).msg_ctime = (src).msg_ctime; \ 1220 } while (/*CONSTCOND*/ 0) 1221 #define FILL_SEM(src, dst) do { \ 1222 FILL_PERM((src).sem_perm, (dst).sem_perm); \ 1223 (dst).sem_nsems = (src).sem_nsems; \ 1224 (dst).sem_otime = (src).sem_otime; \ 1225 (dst).sem_ctime = (src).sem_ctime; \ 1226 } while (/*CONSTCOND*/ 0) 1227 #define FILL_SHM(src, dst) do { \ 1228 FILL_PERM((src).shm_perm, (dst).shm_perm); \ 1229 (dst).shm_segsz = (src).shm_segsz; \ 1230 (dst).shm_lpid = (src).shm_lpid; \ 1231 (dst).shm_cpid = (src).shm_cpid; \ 1232 (dst).shm_atime = (src).shm_atime; \ 1233 (dst).shm_dtime = (src).shm_dtime; \ 1234 (dst).shm_ctime = (src).shm_ctime; \ 1235 (dst).shm_nattch = (src).shm_nattch; \ 1236 } while (/*CONSTCOND*/ 0) 1237 1238 static int 1239 sysctl_kern_sysvipc(SYSCTLFN_ARGS) 1240 { 1241 void *where = oldp; 1242 size_t *sizep = oldlenp; 1243 #ifdef SYSVMSG 1244 struct msg_sysctl_info *msgsi = NULL; 1245 #endif 1246 #ifdef SYSVSEM 1247 struct sem_sysctl_info *semsi = NULL; 1248 #endif 1249 #ifdef SYSVSHM 1250 struct shm_sysctl_info *shmsi = NULL; 1251 #endif 1252 size_t infosize, dssize, tsize, buflen; 1253 void *buf = NULL; 1254 char *start; 1255 int32_t nds; 1256 int i, error, ret; 1257 1258 if (namelen != 1) 1259 return (EINVAL); 1260 1261 start = where; 1262 buflen = *sizep; 1263 1264 switch (*name) { 1265 case KERN_SYSVIPC_MSG_INFO: 1266 #ifdef SYSVMSG 1267 infosize = sizeof(msgsi->msginfo); 1268 nds = msginfo.msgmni; 1269 dssize = sizeof(msgsi->msgids[0]); 1270 break; 1271 #else 1272 return (EINVAL); 1273 #endif 1274 case KERN_SYSVIPC_SEM_INFO: 1275 #ifdef SYSVSEM 1276 infosize = sizeof(semsi->seminfo); 1277 nds = seminfo.semmni; 1278 dssize = sizeof(semsi->semids[0]); 1279 break; 1280 #else 1281 return (EINVAL); 1282 #endif 1283 case KERN_SYSVIPC_SHM_INFO: 1284 #ifdef SYSVSHM 1285 infosize = sizeof(shmsi->shminfo); 1286 nds = shminfo.shmmni; 1287 dssize = sizeof(shmsi->shmids[0]); 1288 break; 1289 #else 1290 return (EINVAL); 1291 #endif 1292 default: 1293 return (EINVAL); 1294 } 1295 /* 1296 * Round infosize to 64 bit boundary if requesting more than just 1297 * the info structure or getting the total data size. 1298 */ 1299 if (where == NULL || *sizep > infosize) 1300 infosize = ((infosize + 7) / 8) * 8; 1301 tsize = infosize + nds * dssize; 1302 1303 /* Return just the total size required. */ 1304 if (where == NULL) { 1305 *sizep = tsize; 1306 return (0); 1307 } 1308 1309 /* Not enough room for even the info struct. */ 1310 if (buflen < infosize) { 1311 *sizep = 0; 1312 return (ENOMEM); 1313 } 1314 buf = malloc(min(tsize, buflen), M_TEMP, M_WAITOK); 1315 memset(buf, 0, min(tsize, buflen)); 1316 1317 switch (*name) { 1318 #ifdef SYSVMSG 1319 case KERN_SYSVIPC_MSG_INFO: 1320 msgsi = (struct msg_sysctl_info *)buf; 1321 msgsi->msginfo = msginfo; 1322 break; 1323 #endif 1324 #ifdef SYSVSEM 1325 case KERN_SYSVIPC_SEM_INFO: 1326 semsi = (struct sem_sysctl_info *)buf; 1327 semsi->seminfo = seminfo; 1328 break; 1329 #endif 1330 #ifdef SYSVSHM 1331 case KERN_SYSVIPC_SHM_INFO: 1332 shmsi = (struct shm_sysctl_info *)buf; 1333 shmsi->shminfo = shminfo; 1334 break; 1335 #endif 1336 } 1337 buflen -= infosize; 1338 1339 ret = 0; 1340 if (buflen > 0) { 1341 /* Fill in the IPC data structures. */ 1342 for (i = 0; i < nds; i++) { 1343 if (buflen < dssize) { 1344 ret = ENOMEM; 1345 break; 1346 } 1347 switch (*name) { 1348 #ifdef SYSVMSG 1349 case KERN_SYSVIPC_MSG_INFO: 1350 FILL_MSG(msqids[i], msgsi->msgids[i]); 1351 break; 1352 #endif 1353 #ifdef SYSVSEM 1354 case KERN_SYSVIPC_SEM_INFO: 1355 FILL_SEM(sema[i], semsi->semids[i]); 1356 break; 1357 #endif 1358 #ifdef SYSVSHM 1359 case KERN_SYSVIPC_SHM_INFO: 1360 FILL_SHM(shmsegs[i], shmsi->shmids[i]); 1361 break; 1362 #endif 1363 } 1364 buflen -= dssize; 1365 } 1366 } 1367 *sizep -= buflen; 1368 error = copyout(buf, start, *sizep); 1369 /* If copyout succeeded, use return code set earlier. */ 1370 if (error == 0) 1371 error = ret; 1372 if (buf) 1373 free(buf, M_TEMP); 1374 return (error); 1375 } 1376 1377 #undef FILL_PERM 1378 #undef FILL_MSG 1379 #undef FILL_SEM 1380 #undef FILL_SHM 1381 1382 #endif /* defined(SYSVMSG) || defined(SYSVSEM) || defined(SYSVSHM) */ 1383 1384 #if NPTY > 0 1385 /* 1386 * sysctl helper routine for kern.maxptys. ensures that any new value 1387 * is acceptable to the pty subsystem. 1388 */ 1389 static int 1390 sysctl_kern_maxptys(SYSCTLFN_ARGS) 1391 { 1392 int pty_maxptys(int, int); /* defined in kern/tty_pty.c */ 1393 int error, max; 1394 struct sysctlnode node; 1395 1396 /* get current value of maxptys */ 1397 max = pty_maxptys(0, 0); 1398 1399 node = *rnode; 1400 node.sysctl_data = &max; 1401 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1402 if (error || newp == NULL) 1403 return (error); 1404 1405 if (max != pty_maxptys(max, 1)) 1406 return (EINVAL); 1407 1408 return (0); 1409 } 1410 #endif /* NPTY > 0 */ 1411 1412 /* 1413 * sysctl helper routine for kern.sbmax. basically just ensures that 1414 * any new value is not too small. 1415 */ 1416 static int 1417 sysctl_kern_sbmax(SYSCTLFN_ARGS) 1418 { 1419 int error, new_sbmax; 1420 struct sysctlnode node; 1421 1422 new_sbmax = sb_max; 1423 node = *rnode; 1424 node.sysctl_data = &new_sbmax; 1425 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1426 if (error || newp == NULL) 1427 return (error); 1428 1429 error = sb_max_set(new_sbmax); 1430 1431 return (error); 1432 } 1433 1434 /* 1435 * sysctl helper routine for kern.urandom node. picks a random number 1436 * for you. 1437 */ 1438 static int 1439 sysctl_kern_urnd(SYSCTLFN_ARGS) 1440 { 1441 #if NRND > 0 1442 int v; 1443 1444 if (rnd_extract_data(&v, sizeof(v), RND_EXTRACT_ANY) == sizeof(v)) { 1445 struct sysctlnode node = *rnode; 1446 node.sysctl_data = &v; 1447 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 1448 } 1449 else 1450 return (EIO); /*XXX*/ 1451 #else 1452 return (EOPNOTSUPP); 1453 #endif 1454 } 1455 1456 /* 1457 * sysctl helper routine to do kern.lwp.* work. 1458 */ 1459 static int 1460 sysctl_kern_lwp(SYSCTLFN_ARGS) 1461 { 1462 struct kinfo_lwp klwp; 1463 struct proc *p; 1464 struct lwp *l2; 1465 char *where, *dp; 1466 int pid, elem_size, elem_count; 1467 int buflen, needed, error; 1468 1469 if (namelen == 1 && name[0] == CTL_QUERY) 1470 return (sysctl_query(SYSCTLFN_CALL(rnode))); 1471 1472 dp = where = oldp; 1473 buflen = where != NULL ? *oldlenp : 0; 1474 error = needed = 0; 1475 1476 if (newp != NULL || namelen != 3) 1477 return (EINVAL); 1478 pid = name[0]; 1479 elem_size = name[1]; 1480 elem_count = name[2]; 1481 1482 p = pfind(pid); 1483 if (p == NULL) 1484 return (ESRCH); 1485 LIST_FOREACH(l2, &p->p_lwps, l_sibling) { 1486 if (buflen >= elem_size && elem_count > 0) { 1487 fill_lwp(l2, &klwp); 1488 /* 1489 * Copy out elem_size, but not larger than 1490 * the size of a struct kinfo_proc2. 1491 */ 1492 error = copyout(&klwp, dp, 1493 min(sizeof(klwp), elem_size)); 1494 if (error) 1495 goto cleanup; 1496 dp += elem_size; 1497 buflen -= elem_size; 1498 elem_count--; 1499 } 1500 needed += elem_size; 1501 } 1502 1503 if (where != NULL) { 1504 *oldlenp = dp - where; 1505 if (needed > *oldlenp) 1506 return (ENOMEM); 1507 } else { 1508 needed += KERN_LWPSLOP; 1509 *oldlenp = needed; 1510 } 1511 return (0); 1512 cleanup: 1513 return (error); 1514 } 1515 1516 /* 1517 * sysctl helper routine for kern.forkfsleep node. ensures that the 1518 * given value is not too large or two small, and is at least one 1519 * timer tick if not zero. 1520 */ 1521 static int 1522 sysctl_kern_forkfsleep(SYSCTLFN_ARGS) 1523 { 1524 /* userland sees value in ms, internally is in ticks */ 1525 extern int forkfsleep; /* defined in kern/kern_fork.c */ 1526 int error, timo, lsleep; 1527 struct sysctlnode node; 1528 1529 lsleep = forkfsleep * 1000 / hz; 1530 node = *rnode; 1531 node.sysctl_data = &lsleep; 1532 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1533 if (error || newp == NULL) 1534 return (error); 1535 1536 /* refuse negative values, and overly 'long time' */ 1537 if (lsleep < 0 || lsleep > MAXSLP * 1000) 1538 return (EINVAL); 1539 1540 timo = mstohz(lsleep); 1541 1542 /* if the interval is >0 ms && <1 tick, use 1 tick */ 1543 if (lsleep != 0 && timo == 0) 1544 forkfsleep = 1; 1545 else 1546 forkfsleep = timo; 1547 1548 return (0); 1549 } 1550 1551 /* 1552 * sysctl helper routine for kern.somaxkva. ensures that the given 1553 * value is not too small. 1554 * (XXX should we maybe make sure it's not too large as well?) 1555 */ 1556 static int 1557 sysctl_kern_somaxkva(SYSCTLFN_ARGS) 1558 { 1559 int error, new_somaxkva; 1560 struct sysctlnode node; 1561 1562 new_somaxkva = somaxkva; 1563 node = *rnode; 1564 node.sysctl_data = &new_somaxkva; 1565 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1566 if (error || newp == NULL) 1567 return (error); 1568 1569 if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */ 1570 return (EINVAL); 1571 somaxkva = new_somaxkva; 1572 1573 return (error); 1574 } 1575 1576 /* 1577 * sysctl helper routine for kern.root_partition 1578 */ 1579 static int 1580 sysctl_kern_root_partition(SYSCTLFN_ARGS) 1581 { 1582 int rootpart = DISKPART(rootdev); 1583 struct sysctlnode node = *rnode; 1584 1585 node.sysctl_data = &rootpart; 1586 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 1587 } 1588 1589 /* 1590 * sysctl helper function for kern.drivers 1591 */ 1592 static int 1593 sysctl_kern_drivers(SYSCTLFN_ARGS) 1594 { 1595 int error; 1596 size_t buflen; 1597 struct kinfo_drivers kd; 1598 char *start, *where; 1599 const char *dname; 1600 int i; 1601 extern struct devsw_conv *devsw_conv; 1602 extern int max_devsw_convs; 1603 1604 if (newp != NULL || namelen != 0) 1605 return (EINVAL); 1606 1607 start = where = oldp; 1608 buflen = *oldlenp; 1609 if (where == NULL) { 1610 *oldlenp = max_devsw_convs * sizeof kd; 1611 return 0; 1612 } 1613 1614 /* 1615 * An array of kinfo_drivers structures 1616 */ 1617 error = 0; 1618 for (i = 0; i < max_devsw_convs; i++) { 1619 dname = devsw_conv[i].d_name; 1620 if (dname == NULL) 1621 continue; 1622 if (buflen < sizeof kd) { 1623 error = ENOMEM; 1624 break; 1625 } 1626 kd.d_bmajor = devsw_conv[i].d_bmajor; 1627 kd.d_cmajor = devsw_conv[i].d_cmajor; 1628 strlcpy(kd.d_name, dname, sizeof kd.d_name); 1629 error = copyout(&kd, where, sizeof kd); 1630 if (error != 0) 1631 break; 1632 buflen -= sizeof kd; 1633 where += sizeof kd; 1634 } 1635 *oldlenp = where - start; 1636 return error; 1637 } 1638 1639 static int 1640 sysctl_doeproc(SYSCTLFN_ARGS) 1641 { 1642 struct eproc eproc; 1643 struct kinfo_proc2 kproc2; 1644 struct kinfo_proc *dp; 1645 struct proc *p; 1646 const struct proclist_desc *pd; 1647 char *where, *dp2; 1648 int type, op, arg; 1649 u_int elem_size, elem_count; 1650 size_t buflen, needed; 1651 int error; 1652 1653 if (namelen == 1 && name[0] == CTL_QUERY) 1654 return (sysctl_query(SYSCTLFN_CALL(rnode))); 1655 1656 dp = oldp; 1657 dp2 = where = oldp; 1658 buflen = where != NULL ? *oldlenp : 0; 1659 error = 0; 1660 needed = 0; 1661 type = rnode->sysctl_num; 1662 1663 if (type == KERN_PROC) { 1664 if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL)) 1665 return (EINVAL); 1666 op = name[0]; 1667 if (op != KERN_PROC_ALL) 1668 arg = name[1]; 1669 else 1670 arg = 0; /* Quell compiler warning */ 1671 elem_size = elem_count = 0; /* Ditto */ 1672 } else { 1673 if (namelen != 4) 1674 return (EINVAL); 1675 op = name[0]; 1676 arg = name[1]; 1677 elem_size = name[2]; 1678 elem_count = name[3]; 1679 } 1680 1681 proclist_lock_read(); 1682 1683 pd = proclists; 1684 again: 1685 for (p = LIST_FIRST(pd->pd_list); p != NULL; p = LIST_NEXT(p, p_list)) { 1686 /* 1687 * Skip embryonic processes. 1688 */ 1689 if (p->p_stat == SIDL) 1690 continue; 1691 /* 1692 * TODO - make more efficient (see notes below). 1693 * do by session. 1694 */ 1695 switch (op) { 1696 1697 case KERN_PROC_PID: 1698 /* could do this with just a lookup */ 1699 if (p->p_pid != (pid_t)arg) 1700 continue; 1701 break; 1702 1703 case KERN_PROC_PGRP: 1704 /* could do this by traversing pgrp */ 1705 if (p->p_pgrp->pg_id != (pid_t)arg) 1706 continue; 1707 break; 1708 1709 case KERN_PROC_SESSION: 1710 if (p->p_session->s_sid != (pid_t)arg) 1711 continue; 1712 break; 1713 1714 case KERN_PROC_TTY: 1715 if (arg == (int) KERN_PROC_TTY_REVOKE) { 1716 if ((p->p_flag & P_CONTROLT) == 0 || 1717 p->p_session->s_ttyp == NULL || 1718 p->p_session->s_ttyvp != NULL) 1719 continue; 1720 } else if ((p->p_flag & P_CONTROLT) == 0 || 1721 p->p_session->s_ttyp == NULL) { 1722 if ((dev_t)arg != KERN_PROC_TTY_NODEV) 1723 continue; 1724 } else if (p->p_session->s_ttyp->t_dev != (dev_t)arg) 1725 continue; 1726 break; 1727 1728 case KERN_PROC_UID: 1729 if (p->p_ucred->cr_uid != (uid_t)arg) 1730 continue; 1731 break; 1732 1733 case KERN_PROC_RUID: 1734 if (p->p_cred->p_ruid != (uid_t)arg) 1735 continue; 1736 break; 1737 1738 case KERN_PROC_GID: 1739 if (p->p_ucred->cr_gid != (uid_t)arg) 1740 continue; 1741 break; 1742 1743 case KERN_PROC_RGID: 1744 if (p->p_cred->p_rgid != (uid_t)arg) 1745 continue; 1746 break; 1747 1748 case KERN_PROC_ALL: 1749 /* allow everything */ 1750 break; 1751 1752 default: 1753 error = EINVAL; 1754 goto cleanup; 1755 } 1756 if (type == KERN_PROC) { 1757 if (buflen >= sizeof(struct kinfo_proc)) { 1758 fill_eproc(p, &eproc); 1759 error = copyout(p, &dp->kp_proc, 1760 sizeof(struct proc)); 1761 if (error) 1762 goto cleanup; 1763 error = copyout(&eproc, &dp->kp_eproc, 1764 sizeof(eproc)); 1765 if (error) 1766 goto cleanup; 1767 dp++; 1768 buflen -= sizeof(struct kinfo_proc); 1769 } 1770 needed += sizeof(struct kinfo_proc); 1771 } else { /* KERN_PROC2 */ 1772 if (buflen >= elem_size && elem_count > 0) { 1773 fill_kproc2(p, &kproc2); 1774 /* 1775 * Copy out elem_size, but not larger than 1776 * the size of a struct kinfo_proc2. 1777 */ 1778 error = copyout(&kproc2, dp2, 1779 min(sizeof(kproc2), elem_size)); 1780 if (error) 1781 goto cleanup; 1782 dp2 += elem_size; 1783 buflen -= elem_size; 1784 elem_count--; 1785 } 1786 needed += elem_size; 1787 } 1788 } 1789 pd++; 1790 if (pd->pd_list != NULL) 1791 goto again; 1792 proclist_unlock_read(); 1793 1794 if (where != NULL) { 1795 if (type == KERN_PROC) 1796 *oldlenp = (char *)dp - where; 1797 else 1798 *oldlenp = dp2 - where; 1799 if (needed > *oldlenp) 1800 return (ENOMEM); 1801 } else { 1802 needed += KERN_PROCSLOP; 1803 *oldlenp = needed; 1804 } 1805 return (0); 1806 cleanup: 1807 proclist_unlock_read(); 1808 return (error); 1809 } 1810 1811 /* 1812 * sysctl helper routine for kern.proc_args pseudo-subtree. 1813 */ 1814 static int 1815 sysctl_kern_proc_args(SYSCTLFN_ARGS) 1816 { 1817 struct ps_strings pss; 1818 struct proc *p, *up = l->l_proc; 1819 size_t len, upper_bound, xlen, i; 1820 struct uio auio; 1821 struct iovec aiov; 1822 vaddr_t argv; 1823 pid_t pid; 1824 int nargv, type, error; 1825 char *arg; 1826 char *tmp; 1827 1828 if (namelen == 1 && name[0] == CTL_QUERY) 1829 return (sysctl_query(SYSCTLFN_CALL(rnode))); 1830 1831 if (newp != NULL || namelen != 2) 1832 return (EINVAL); 1833 pid = name[0]; 1834 type = name[1]; 1835 1836 switch (type) { 1837 case KERN_PROC_ARGV: 1838 case KERN_PROC_NARGV: 1839 case KERN_PROC_ENV: 1840 case KERN_PROC_NENV: 1841 /* ok */ 1842 break; 1843 default: 1844 return (EINVAL); 1845 } 1846 1847 /* check pid */ 1848 if ((p = pfind(pid)) == NULL) 1849 return (EINVAL); 1850 1851 /* only root or same user change look at the environment */ 1852 if (type == KERN_PROC_ENV || type == KERN_PROC_NENV) { 1853 if (up->p_ucred->cr_uid != 0) { 1854 if (up->p_cred->p_ruid != p->p_cred->p_ruid || 1855 up->p_cred->p_ruid != p->p_cred->p_svuid) 1856 return (EPERM); 1857 } 1858 } 1859 1860 if (oldp == NULL) { 1861 if (type == KERN_PROC_NARGV || type == KERN_PROC_NENV) 1862 *oldlenp = sizeof (int); 1863 else 1864 *oldlenp = ARG_MAX; /* XXX XXX XXX */ 1865 return (0); 1866 } 1867 1868 /* 1869 * Zombies don't have a stack, so we can't read their psstrings. 1870 * System processes also don't have a user stack. 1871 */ 1872 if (P_ZOMBIE(p) || (p->p_flag & P_SYSTEM) != 0) 1873 return (EINVAL); 1874 1875 /* 1876 * Lock the process down in memory. 1877 */ 1878 /* XXXCDC: how should locking work here? */ 1879 if ((p->p_flag & P_WEXIT) || (p->p_vmspace->vm_refcnt < 1)) 1880 return (EFAULT); 1881 1882 p->p_vmspace->vm_refcnt++; /* XXX */ 1883 1884 /* 1885 * Allocate a temporary buffer to hold the arguments. 1886 */ 1887 arg = malloc(PAGE_SIZE, M_TEMP, M_WAITOK); 1888 1889 /* 1890 * Read in the ps_strings structure. 1891 */ 1892 aiov.iov_base = &pss; 1893 aiov.iov_len = sizeof(pss); 1894 auio.uio_iov = &aiov; 1895 auio.uio_iovcnt = 1; 1896 auio.uio_offset = (vaddr_t)p->p_psstr; 1897 auio.uio_resid = sizeof(pss); 1898 auio.uio_segflg = UIO_SYSSPACE; 1899 auio.uio_rw = UIO_READ; 1900 auio.uio_procp = NULL; 1901 error = uvm_io(&p->p_vmspace->vm_map, &auio); 1902 if (error) 1903 goto done; 1904 1905 if (type == KERN_PROC_ARGV || type == KERN_PROC_NARGV) 1906 memcpy(&nargv, (char *)&pss + p->p_psnargv, sizeof(nargv)); 1907 else 1908 memcpy(&nargv, (char *)&pss + p->p_psnenv, sizeof(nargv)); 1909 if (type == KERN_PROC_NARGV || type == KERN_PROC_NENV) { 1910 error = copyout(&nargv, oldp, sizeof(nargv)); 1911 *oldlenp = sizeof(nargv); 1912 goto done; 1913 } 1914 /* 1915 * Now read the address of the argument vector. 1916 */ 1917 switch (type) { 1918 case KERN_PROC_ARGV: 1919 /* XXX compat32 stuff here */ 1920 memcpy(&tmp, (char *)&pss + p->p_psargv, sizeof(tmp)); 1921 break; 1922 case KERN_PROC_ENV: 1923 memcpy(&tmp, (char *)&pss + p->p_psenv, sizeof(tmp)); 1924 break; 1925 default: 1926 return (EINVAL); 1927 } 1928 auio.uio_offset = (off_t)(long)tmp; 1929 aiov.iov_base = &argv; 1930 aiov.iov_len = sizeof(argv); 1931 auio.uio_iov = &aiov; 1932 auio.uio_iovcnt = 1; 1933 auio.uio_resid = sizeof(argv); 1934 auio.uio_segflg = UIO_SYSSPACE; 1935 auio.uio_rw = UIO_READ; 1936 auio.uio_procp = NULL; 1937 error = uvm_io(&p->p_vmspace->vm_map, &auio); 1938 if (error) 1939 goto done; 1940 1941 /* 1942 * Now copy in the actual argument vector, one page at a time, 1943 * since we don't know how long the vector is (though, we do 1944 * know how many NUL-terminated strings are in the vector). 1945 */ 1946 len = 0; 1947 upper_bound = *oldlenp; 1948 for (; nargv != 0 && len < upper_bound; len += xlen) { 1949 aiov.iov_base = arg; 1950 aiov.iov_len = PAGE_SIZE; 1951 auio.uio_iov = &aiov; 1952 auio.uio_iovcnt = 1; 1953 auio.uio_offset = argv + len; 1954 xlen = PAGE_SIZE - ((argv + len) & PAGE_MASK); 1955 auio.uio_resid = xlen; 1956 auio.uio_segflg = UIO_SYSSPACE; 1957 auio.uio_rw = UIO_READ; 1958 auio.uio_procp = NULL; 1959 error = uvm_io(&p->p_vmspace->vm_map, &auio); 1960 if (error) 1961 goto done; 1962 1963 for (i = 0; i < xlen && nargv != 0; i++) { 1964 if (arg[i] == '\0') 1965 nargv--; /* one full string */ 1966 } 1967 1968 /* 1969 * Make sure we don't copyout past the end of the user's 1970 * buffer. 1971 */ 1972 if (len + i > upper_bound) 1973 i = upper_bound - len; 1974 1975 error = copyout(arg, (char *)oldp + len, i); 1976 if (error) 1977 break; 1978 1979 if (nargv == 0) { 1980 len += i; 1981 break; 1982 } 1983 } 1984 *oldlenp = len; 1985 1986 done: 1987 uvmspace_free(p->p_vmspace); 1988 1989 free(arg, M_TEMP); 1990 return (error); 1991 } 1992 1993 /* 1994 * sysctl helper routine for hw.usermem and hw.usermem64. values are 1995 * calculate on the fly taking into account integer overflow and the 1996 * current wired count. 1997 */ 1998 static int 1999 sysctl_hw_usermem(SYSCTLFN_ARGS) 2000 { 2001 u_int ui; 2002 u_quad_t uq; 2003 struct sysctlnode node; 2004 2005 node = *rnode; 2006 switch (rnode->sysctl_num) { 2007 case HW_USERMEM: 2008 if ((ui = physmem - uvmexp.wired) > (UINT_MAX / PAGE_SIZE)) 2009 ui = UINT_MAX; 2010 else 2011 ui *= PAGE_SIZE; 2012 node.sysctl_data = &ui; 2013 break; 2014 case HW_USERMEM64: 2015 uq = (u_quad_t)(physmem - uvmexp.wired) * PAGE_SIZE; 2016 node.sysctl_data = &uq; 2017 break; 2018 default: 2019 return (EINVAL); 2020 } 2021 2022 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 2023 } 2024 2025 /* 2026 * sysctl helper routine for kern.cnmagic node. pulls the old value 2027 * out, encoded, and stuffs the new value in for decoding. 2028 */ 2029 static int 2030 sysctl_hw_cnmagic(SYSCTLFN_ARGS) 2031 { 2032 char magic[CNS_LEN]; 2033 int error; 2034 struct sysctlnode node; 2035 2036 if (oldp) 2037 cn_get_magic(magic, CNS_LEN); 2038 node = *rnode; 2039 node.sysctl_data = &magic[0]; 2040 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2041 if (error || newp == NULL) 2042 return (error); 2043 2044 return (cn_set_magic(magic)); 2045 } 2046 2047 static int 2048 sysctl_hw_ncpu(SYSCTLFN_ARGS) 2049 { 2050 int ncpu; 2051 struct sysctlnode node; 2052 2053 ncpu = sysctl_ncpus(); 2054 node = *rnode; 2055 node.sysctl_data = &ncpu; 2056 2057 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 2058 } 2059 2060 2061 /* 2062 * ******************************************************************** 2063 * section 3: public helper routines that are used for more than one 2064 * node 2065 * ******************************************************************** 2066 */ 2067 2068 /* 2069 * sysctl helper routine for the kern.root_device node and some ports' 2070 * machdep.root_device nodes. 2071 */ 2072 int 2073 sysctl_root_device(SYSCTLFN_ARGS) 2074 { 2075 struct sysctlnode node; 2076 2077 node = *rnode; 2078 node.sysctl_data = root_device->dv_xname; 2079 node.sysctl_size = strlen(root_device->dv_xname) + 1; 2080 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 2081 } 2082 2083 /* 2084 * sysctl helper routine for kern.consdev, dependent on the current 2085 * state of the console. also used for machdep.console_device on some 2086 * ports. 2087 */ 2088 int 2089 sysctl_consdev(SYSCTLFN_ARGS) 2090 { 2091 dev_t consdev; 2092 struct sysctlnode node; 2093 2094 if (cn_tab != NULL) 2095 consdev = cn_tab->cn_dev; 2096 else 2097 consdev = NODEV; 2098 node = *rnode; 2099 node.sysctl_data = &consdev; 2100 node.sysctl_size = sizeof(consdev); 2101 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 2102 } 2103 2104 /* 2105 * ******************************************************************** 2106 * section 4: support for some helpers 2107 * ******************************************************************** 2108 */ 2109 2110 /* 2111 * Fill in a kinfo_proc2 structure for the specified process. 2112 */ 2113 static void 2114 fill_kproc2(struct proc *p, struct kinfo_proc2 *ki) 2115 { 2116 struct tty *tp; 2117 struct lwp *l; 2118 struct timeval ut, st; 2119 2120 memset(ki, 0, sizeof(*ki)); 2121 2122 ki->p_paddr = PTRTOUINT64(p); 2123 ki->p_fd = PTRTOUINT64(p->p_fd); 2124 ki->p_cwdi = PTRTOUINT64(p->p_cwdi); 2125 ki->p_stats = PTRTOUINT64(p->p_stats); 2126 ki->p_limit = PTRTOUINT64(p->p_limit); 2127 ki->p_vmspace = PTRTOUINT64(p->p_vmspace); 2128 ki->p_sigacts = PTRTOUINT64(p->p_sigacts); 2129 ki->p_sess = PTRTOUINT64(p->p_session); 2130 ki->p_tsess = 0; /* may be changed if controlling tty below */ 2131 ki->p_ru = PTRTOUINT64(p->p_ru); 2132 2133 ki->p_eflag = 0; 2134 ki->p_exitsig = p->p_exitsig; 2135 ki->p_flag = p->p_flag; 2136 2137 ki->p_pid = p->p_pid; 2138 if (p->p_pptr) 2139 ki->p_ppid = p->p_pptr->p_pid; 2140 else 2141 ki->p_ppid = 0; 2142 ki->p_sid = p->p_session->s_sid; 2143 ki->p__pgid = p->p_pgrp->pg_id; 2144 2145 ki->p_tpgid = NO_PGID; /* may be changed if controlling tty below */ 2146 2147 ki->p_uid = p->p_ucred->cr_uid; 2148 ki->p_ruid = p->p_cred->p_ruid; 2149 ki->p_gid = p->p_ucred->cr_gid; 2150 ki->p_rgid = p->p_cred->p_rgid; 2151 ki->p_svuid = p->p_cred->p_svuid; 2152 ki->p_svgid = p->p_cred->p_svgid; 2153 2154 memcpy(ki->p_groups, p->p_cred->pc_ucred->cr_groups, 2155 min(sizeof(ki->p_groups), sizeof(p->p_cred->pc_ucred->cr_groups))); 2156 ki->p_ngroups = p->p_cred->pc_ucred->cr_ngroups; 2157 2158 ki->p_jobc = p->p_pgrp->pg_jobc; 2159 if ((p->p_flag & P_CONTROLT) && (tp = p->p_session->s_ttyp)) { 2160 ki->p_tdev = tp->t_dev; 2161 ki->p_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID; 2162 ki->p_tsess = PTRTOUINT64(tp->t_session); 2163 } else { 2164 ki->p_tdev = NODEV; 2165 } 2166 2167 ki->p_estcpu = p->p_estcpu; 2168 ki->p_rtime_sec = p->p_rtime.tv_sec; 2169 ki->p_rtime_usec = p->p_rtime.tv_usec; 2170 ki->p_cpticks = p->p_cpticks; 2171 ki->p_pctcpu = p->p_pctcpu; 2172 2173 ki->p_uticks = p->p_uticks; 2174 ki->p_sticks = p->p_sticks; 2175 ki->p_iticks = p->p_iticks; 2176 2177 ki->p_tracep = PTRTOUINT64(p->p_tracep); 2178 ki->p_traceflag = p->p_traceflag; 2179 2180 2181 memcpy(&ki->p_siglist, &p->p_sigctx.ps_siglist, sizeof(ki_sigset_t)); 2182 memcpy(&ki->p_sigmask, &p->p_sigctx.ps_sigmask, sizeof(ki_sigset_t)); 2183 memcpy(&ki->p_sigignore, &p->p_sigctx.ps_sigignore,sizeof(ki_sigset_t)); 2184 memcpy(&ki->p_sigcatch, &p->p_sigctx.ps_sigcatch, sizeof(ki_sigset_t)); 2185 2186 ki->p_stat = p->p_stat; /* Will likely be overridden by LWP status */ 2187 ki->p_realstat = p->p_stat; 2188 ki->p_nice = p->p_nice; 2189 2190 ki->p_xstat = p->p_xstat; 2191 ki->p_acflag = p->p_acflag; 2192 2193 strncpy(ki->p_comm, p->p_comm, 2194 min(sizeof(ki->p_comm), sizeof(p->p_comm))); 2195 2196 strncpy(ki->p_login, p->p_session->s_login, 2197 min(sizeof ki->p_login - 1, sizeof p->p_session->s_login)); 2198 2199 ki->p_nlwps = p->p_nlwps; 2200 ki->p_nrlwps = p->p_nrlwps; 2201 ki->p_realflag = p->p_flag; 2202 2203 if (p->p_stat == SIDL || P_ZOMBIE(p)) { 2204 ki->p_vm_rssize = 0; 2205 ki->p_vm_tsize = 0; 2206 ki->p_vm_dsize = 0; 2207 ki->p_vm_ssize = 0; 2208 l = NULL; 2209 } else { 2210 struct vmspace *vm = p->p_vmspace; 2211 2212 ki->p_vm_rssize = vm_resident_count(vm); 2213 ki->p_vm_tsize = vm->vm_tsize; 2214 ki->p_vm_dsize = vm->vm_dsize; 2215 ki->p_vm_ssize = vm->vm_ssize; 2216 2217 /* Pick a "representative" LWP */ 2218 l = proc_representative_lwp(p); 2219 ki->p_forw = PTRTOUINT64(l->l_forw); 2220 ki->p_back = PTRTOUINT64(l->l_back); 2221 ki->p_addr = PTRTOUINT64(l->l_addr); 2222 ki->p_stat = l->l_stat; 2223 ki->p_flag |= l->l_flag; 2224 ki->p_swtime = l->l_swtime; 2225 ki->p_slptime = l->l_slptime; 2226 if (l->l_stat == LSONPROC) { 2227 KDASSERT(l->l_cpu != NULL); 2228 ki->p_schedflags = l->l_cpu->ci_schedstate.spc_flags; 2229 } else 2230 ki->p_schedflags = 0; 2231 ki->p_holdcnt = l->l_holdcnt; 2232 ki->p_priority = l->l_priority; 2233 ki->p_usrpri = l->l_usrpri; 2234 if (l->l_wmesg) 2235 strncpy(ki->p_wmesg, l->l_wmesg, sizeof(ki->p_wmesg)); 2236 ki->p_wchan = PTRTOUINT64(l->l_wchan); 2237 2238 } 2239 2240 if (p->p_session->s_ttyvp) 2241 ki->p_eflag |= EPROC_CTTY; 2242 if (SESS_LEADER(p)) 2243 ki->p_eflag |= EPROC_SLEADER; 2244 2245 /* XXX Is this double check necessary? */ 2246 if (P_ZOMBIE(p)) { 2247 ki->p_uvalid = 0; 2248 } else { 2249 ki->p_uvalid = 1; 2250 2251 ki->p_ustart_sec = p->p_stats->p_start.tv_sec; 2252 ki->p_ustart_usec = p->p_stats->p_start.tv_usec; 2253 2254 calcru(p, &ut, &st, 0); 2255 ki->p_uutime_sec = ut.tv_sec; 2256 ki->p_uutime_usec = ut.tv_usec; 2257 ki->p_ustime_sec = st.tv_sec; 2258 ki->p_ustime_usec = st.tv_usec; 2259 2260 ki->p_uru_maxrss = p->p_stats->p_ru.ru_maxrss; 2261 ki->p_uru_ixrss = p->p_stats->p_ru.ru_ixrss; 2262 ki->p_uru_idrss = p->p_stats->p_ru.ru_idrss; 2263 ki->p_uru_isrss = p->p_stats->p_ru.ru_isrss; 2264 ki->p_uru_minflt = p->p_stats->p_ru.ru_minflt; 2265 ki->p_uru_majflt = p->p_stats->p_ru.ru_majflt; 2266 ki->p_uru_nswap = p->p_stats->p_ru.ru_nswap; 2267 ki->p_uru_inblock = p->p_stats->p_ru.ru_inblock; 2268 ki->p_uru_oublock = p->p_stats->p_ru.ru_oublock; 2269 ki->p_uru_msgsnd = p->p_stats->p_ru.ru_msgsnd; 2270 ki->p_uru_msgrcv = p->p_stats->p_ru.ru_msgrcv; 2271 ki->p_uru_nsignals = p->p_stats->p_ru.ru_nsignals; 2272 ki->p_uru_nvcsw = p->p_stats->p_ru.ru_nvcsw; 2273 ki->p_uru_nivcsw = p->p_stats->p_ru.ru_nivcsw; 2274 2275 timeradd(&p->p_stats->p_cru.ru_utime, 2276 &p->p_stats->p_cru.ru_stime, &ut); 2277 ki->p_uctime_sec = ut.tv_sec; 2278 ki->p_uctime_usec = ut.tv_usec; 2279 } 2280 #ifdef MULTIPROCESSOR 2281 if (l && l->l_cpu != NULL) 2282 ki->p_cpuid = l->l_cpu->ci_cpuid; 2283 else 2284 #endif 2285 ki->p_cpuid = KI_NOCPU; 2286 } 2287 2288 /* 2289 * Fill in a kinfo_lwp structure for the specified lwp. 2290 */ 2291 static void 2292 fill_lwp(struct lwp *l, struct kinfo_lwp *kl) 2293 { 2294 2295 kl->l_forw = PTRTOUINT64(l->l_forw); 2296 kl->l_back = PTRTOUINT64(l->l_back); 2297 kl->l_laddr = PTRTOUINT64(l); 2298 kl->l_addr = PTRTOUINT64(l->l_addr); 2299 kl->l_stat = l->l_stat; 2300 kl->l_lid = l->l_lid; 2301 kl->l_flag = l->l_flag; 2302 2303 kl->l_swtime = l->l_swtime; 2304 kl->l_slptime = l->l_slptime; 2305 if (l->l_stat == LSONPROC) { 2306 KDASSERT(l->l_cpu != NULL); 2307 kl->l_schedflags = l->l_cpu->ci_schedstate.spc_flags; 2308 } else 2309 kl->l_schedflags = 0; 2310 kl->l_holdcnt = l->l_holdcnt; 2311 kl->l_priority = l->l_priority; 2312 kl->l_usrpri = l->l_usrpri; 2313 if (l->l_wmesg) 2314 strncpy(kl->l_wmesg, l->l_wmesg, sizeof(kl->l_wmesg)); 2315 kl->l_wchan = PTRTOUINT64(l->l_wchan); 2316 #ifdef MULTIPROCESSOR 2317 if (l->l_cpu != NULL) 2318 kl->l_cpuid = l->l_cpu->ci_cpuid; 2319 else 2320 #endif 2321 kl->l_cpuid = KI_NOCPU; 2322 } 2323 2324 /* 2325 * Fill in an eproc structure for the specified process. 2326 */ 2327 void 2328 fill_eproc(struct proc *p, struct eproc *ep) 2329 { 2330 struct tty *tp; 2331 struct lwp *l; 2332 2333 ep->e_paddr = p; 2334 ep->e_sess = p->p_session; 2335 ep->e_pcred = *p->p_cred; 2336 ep->e_ucred = *p->p_ucred; 2337 if (p->p_stat == SIDL || P_ZOMBIE(p)) { 2338 ep->e_vm.vm_rssize = 0; 2339 ep->e_vm.vm_tsize = 0; 2340 ep->e_vm.vm_dsize = 0; 2341 ep->e_vm.vm_ssize = 0; 2342 /* ep->e_vm.vm_pmap = XXX; */ 2343 } else { 2344 struct vmspace *vm = p->p_vmspace; 2345 2346 ep->e_vm.vm_rssize = vm_resident_count(vm); 2347 ep->e_vm.vm_tsize = vm->vm_tsize; 2348 ep->e_vm.vm_dsize = vm->vm_dsize; 2349 ep->e_vm.vm_ssize = vm->vm_ssize; 2350 2351 /* Pick a "representative" LWP */ 2352 l = proc_representative_lwp(p); 2353 2354 if (l->l_wmesg) 2355 strncpy(ep->e_wmesg, l->l_wmesg, WMESGLEN); 2356 } 2357 if (p->p_pptr) 2358 ep->e_ppid = p->p_pptr->p_pid; 2359 else 2360 ep->e_ppid = 0; 2361 ep->e_pgid = p->p_pgrp->pg_id; 2362 ep->e_sid = ep->e_sess->s_sid; 2363 ep->e_jobc = p->p_pgrp->pg_jobc; 2364 if ((p->p_flag & P_CONTROLT) && 2365 (tp = ep->e_sess->s_ttyp)) { 2366 ep->e_tdev = tp->t_dev; 2367 ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID; 2368 ep->e_tsess = tp->t_session; 2369 } else 2370 ep->e_tdev = NODEV; 2371 2372 ep->e_xsize = ep->e_xrssize = 0; 2373 ep->e_xccount = ep->e_xswrss = 0; 2374 ep->e_flag = ep->e_sess->s_ttyvp ? EPROC_CTTY : 0; 2375 if (SESS_LEADER(p)) 2376 ep->e_flag |= EPROC_SLEADER; 2377 strncpy(ep->e_login, ep->e_sess->s_login, MAXLOGNAME); 2378 } 2379
Indexes created Wed Oct 01 15:09:59 GMT 2025