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