1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 22 /* All Rights Reserved */ 23 24 25 /* 26 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 #ifndef _SYS_SYSTM_H 31 #define _SYS_SYSTM_H 32 33 #include <sys/types.h> 34 #include <sys/t_lock.h> 35 #include <sys/proc.h> 36 #include <sys/dditypes.h> 37 38 #ifdef __cplusplus 39 extern "C" { 40 #endif 41 42 /* 43 * The pc_t is the type of the kernel's program counter. In general, a 44 * pc_t is a uintptr_t -- except for a sparcv9 kernel, in which case all 45 * instruction text is below 4G, and a pc_t is thus a uint32_t. 46 */ 47 #ifdef __sparcv9 48 typedef uint32_t pc_t; 49 #else 50 typedef uintptr_t pc_t; 51 #endif 52 53 /* 54 * Random set of variables used by more than one routine. 55 */ 56 57 #if defined(_KERNEL) || defined(_FAKE_KERNEL) 58 #include <sys/types32.h> 59 #include <sys/varargs.h> 60 #include <sys/uadmin.h> 61 62 extern int hz; /* system clock rate */ 63 extern struct vnode *rootdir; /* pointer to vnode of root directory */ 64 extern struct vnode *devicesdir; /* pointer to /devices vnode */ 65 extern int interrupts_unleashed; /* set after the spl0() in main() */ 66 67 extern pgcnt_t maxmem; /* max available memory (pages) */ 68 extern pgcnt_t physmem; /* physical memory (pages) on this CPU */ 69 extern pfn_t physmax; /* highest numbered physical page present */ 70 extern pgcnt_t physinstalled; /* physical pages including PROM/boot use */ 71 72 extern caddr_t s_text; /* start of kernel text segment */ 73 extern caddr_t e_text; /* end of kernel text segment */ 74 extern caddr_t s_data; /* start of kernel text segment */ 75 extern caddr_t e_data; /* end of kernel text segment */ 76 77 extern pgcnt_t availrmem; /* Available resident (not swapable) */ 78 /* memory in pages. */ 79 extern pgcnt_t availrmem_initial; /* initial value of availrmem */ 80 extern pgcnt_t segspt_minfree; /* low water mark for availrmem in seg_spt */ 81 extern pgcnt_t freemem; /* Current free memory. */ 82 83 extern dev_t rootdev; /* device of the root */ 84 extern struct vnode *rootvp; /* vnode of root device */ 85 extern boolean_t root_is_svm; /* root is a mirrored device flag */ 86 extern boolean_t root_is_ramdisk; /* root is boot_archive ramdisk */ 87 extern uint32_t ramdisk_size; /* (KB) set only for sparc netboots */ 88 extern char *volatile panicstr; /* panic string pointer */ 89 extern va_list panicargs; /* panic arguments */ 90 extern volatile int quiesce_active; /* quiesce(9E) is in progress */ 91 92 extern int rstchown; /* 1 ==> restrictive chown(2) semantics */ 93 extern int klustsize; 94 95 extern int abort_enable; /* Platform input-device abort policy */ 96 97 extern int audit_active; /* Solaris Auditing module state */ 98 99 extern int avenrun[]; /* array of load averages */ 100 101 extern char *isa_list; /* For sysinfo's isalist option */ 102 103 extern int noexec_user_stack; /* patchable via /etc/system */ 104 extern int noexec_user_stack_log; /* patchable via /etc/system */ 105 106 /* 107 * Use NFS client operations in the global zone only. Under contract with 108 * admin/install; do not change without coordinating with that consolidation. 109 */ 110 extern int nfs_global_client_only; 111 112 extern void report_stack_exec(proc_t *, caddr_t); 113 114 extern void startup(void); 115 extern void clkstart(void); 116 extern void post_startup(void); 117 extern void kern_setup1(void); 118 extern void ka_init(void); 119 extern void nodename_set(void); 120 121 /* 122 * for tod fault detection 123 */ 124 enum tod_fault_type { 125 TOD_REVERSED = 0, 126 TOD_STALLED, 127 TOD_JUMPED, 128 TOD_RATECHANGED, 129 TOD_RDONLY, 130 TOD_NOFAULT 131 }; 132 133 #define TOD_GET_FAILED 0x1 /* TOD could not be read */ 134 #define TOD_SET_DONE 0x2 /* TOD has been modified */ 135 #define TOD_CPR_RESUME_DONE 0x4 /* CPR resume has occurred */ 136 #define TOD_DR_RESUME_DONE 0x8 /* DR resume has occurred */ 137 138 extern time_t tod_validate(time_t); 139 extern void tod_status_set(int); 140 extern void tod_status_clear(int); 141 extern void plat_tod_fault(enum tod_fault_type); 142 143 #ifndef _LP64 144 #ifndef min 145 int min(int, int); 146 #endif 147 148 #ifndef max 149 int max(int, int); 150 #endif 151 152 uint_t umin(uint_t, uint_t); 153 uint_t umax(uint_t, uint_t); 154 #endif /* !_LP64 */ 155 int grow(caddr_t); 156 int grow_internal(caddr_t, uint_t); 157 int brk_internal(caddr_t, uint_t); 158 typedef uint64_t callout_id_t; 159 timeout_id_t timeout(void (*)(void *), void *, clock_t); 160 timeout_id_t realtime_timeout(void (*)(void *), void *, clock_t); 161 clock_t untimeout(timeout_id_t); 162 /* 163 * The last argument to timeout_generic() is flags. See callo.h for the 164 * flags definitions. 165 */ 166 callout_id_t timeout_generic(int, void (*)(void *), void *, hrtime_t, hrtime_t, 167 int); 168 callout_id_t timeout_default(void (*)(void *), void *, clock_t); 169 callout_id_t realtime_timeout_default(void (*)(void *), void *, clock_t); 170 /* 171 * The last argument to untimeout_generic() is flags. See callout.c for the 172 * use. 173 */ 174 hrtime_t untimeout_generic(callout_id_t, int); 175 clock_t untimeout_default(callout_id_t, int); 176 void delay(clock_t); 177 int delay_sig(clock_t); 178 void delay_random(clock_t); 179 int nodev(); 180 int nulldev(); 181 major_t getudev(void); 182 int cmpldev(dev32_t *, dev_t); 183 dev_t expldev(dev32_t); 184 int bcmp(const void *, const void *, size_t) __PURE; 185 int stoi(char **); 186 void numtos(ulong_t, char *); 187 char *kmem_asprintf(const char *fmt, ...); 188 int strident_valid(const char *); 189 void strident_canon(char *, size_t); 190 int getsubopt(char **optionsp, char * const *tokens, char **valuep); 191 char *append_subopt(const char *, size_t, char *, const char *); 192 #ifndef _FAKE_KERNEL 193 /* conflicts with libc definition */ 194 int ffs(uintmax_t); 195 #endif 196 int copyin(const void *, void *, size_t); 197 void copyin_noerr(const void *, void *, size_t); 198 int xcopyin(const void *, void *, size_t); 199 int xcopyin_nta(const void *, void *, size_t, int); 200 int copyout(const void *, void *, size_t); 201 void copyout_noerr(const void *, void *, size_t); 202 int xcopyout(const void *, void *, size_t); 203 int xcopyout_nta(const void *, void *, size_t, int); 204 int copyinstr(const char *, char *, size_t, size_t *); 205 int copyinstr_noerr(const char *, char *, size_t, size_t *); 206 int copyoutstr(const char *, char *, size_t, size_t *); 207 int copyoutstr_noerr(const char *, char *, size_t, size_t *); 208 int copystr(const char *, char *, size_t, size_t *); 209 void ucopy(const void *, void *, size_t); 210 void ucopystr(const char *, char *, size_t, size_t *); 211 void pgcopy(const void *, void *, size_t); 212 void ovbcopy(const void *, void *, size_t); 213 void uzero(void *, size_t); 214 int kcopy(const void *, void *, size_t); 215 int kcopy_nta(const void *, void *, size_t, int); 216 int kzero(void *, size_t); 217 218 int fuword8(const void *, uint8_t *); 219 int fuword16(const void *, uint16_t *); 220 int fuword32(const void *, uint32_t *); 221 int fulword(const void *, ulong_t *); 222 void fuword8_noerr(const void *, uint8_t *); 223 void fuword16_noerr(const void *, uint16_t *); 224 void fuword32_noerr(const void *, uint32_t *); 225 void fulword_noerr(const void *, ulong_t *); 226 227 #ifdef _LP64 228 int fuword64(const void *, uint64_t *); 229 void fuword64_noerr(const void *, uint64_t *); 230 #endif 231 232 int subyte(void *, uint8_t); 233 int suword8(void *, uint8_t); 234 int suword16(void *, uint16_t); 235 int suword32(void *, uint32_t); 236 int sulword(void *, ulong_t); 237 void subyte_noerr(void *, uint8_t); 238 void suword8_noerr(void *, uint8_t); 239 void suword16_noerr(void *, uint16_t); 240 void suword32_noerr(void *, uint32_t); 241 void sulword_noerr(void *, ulong_t); 242 243 #ifdef _LP64 244 int suword64(void *, uint64_t); 245 void suword64_noerr(void *, uint64_t); 246 #endif 247 248 #if !defined(_BOOT) && !defined(_FAKE_KERNEL) 249 /* conflicts with libc definition */ 250 int setjmp(label_t *) __RETURNS_TWICE; 251 extern void longjmp(label_t *) 252 __NORETURN; 253 #pragma unknown_control_flow(setjmp) 254 #endif 255 256 void prefetch_read_once(void *); 257 void prefetch_write_once(void *); 258 void prefetch_read_many(void *); 259 void prefetch_write_many(void *); 260 caddr_t caller(void); 261 caddr_t callee(void); 262 int getpcstack(pc_t *, int); 263 int on_fault(label_t *) __RETURNS_TWICE; 264 void no_fault(void); 265 void halt(char *); 266 int scanc(size_t, uchar_t *, uchar_t *, uchar_t); 267 int movtuc(size_t, uchar_t *, uchar_t *, uchar_t *); 268 int splr(int); 269 int splhigh(void); 270 int splhi(void); 271 int splzs(void); 272 int spl0(void); 273 int spl6(void); 274 int spl7(void); 275 int spl8(void); 276 void splx(int); 277 void set_base_spl(void); 278 int __ipltospl(int); 279 int spl_xcall(void); 280 281 void softcall_init(void); 282 void softcall(void (*)(void *), void *); 283 void softint(void); 284 285 extern void sync_icache(caddr_t, uint_t); 286 extern void sync_data_memory(caddr_t, size_t); 287 extern void hot_patch_kernel_text(caddr_t, uint32_t, uint_t); 288 289 void _insque(caddr_t, caddr_t); 290 void _remque(caddr_t); 291 292 /* casts to keep lint happy */ 293 #define insque(q, p) _insque((caddr_t)q, (caddr_t)p) 294 #define remque(q) _remque((caddr_t)q) 295 296 #pragma unknown_control_flow(on_fault) 297 298 struct timeval; 299 extern void uniqtime(struct timeval *); 300 struct timeval32; 301 extern void uniqtime32(struct timeval32 *); 302 303 uint_t page_num_pagesizes(void); 304 size_t page_get_pagesize(uint_t n); 305 306 extern int maxusers; 307 extern int pidmax; 308 309 extern void param_preset(void); 310 extern void param_calc(int); 311 extern void param_init(void); 312 extern void param_check(void); 313 314 #endif /* _KERNEL */ 315 316 /* 317 * Structure of the system-entry table. 318 * 319 * Changes to struct sysent should maintain binary compatibility with 320 * loadable system calls, although the interface is currently private. 321 * 322 * This means it should only be expanded on the end, and flag values 323 * should not be reused. 324 * 325 * It is desirable to keep the size of this struct a power of 2 for quick 326 * indexing. 327 */ 328 struct sysent { 329 char sy_narg; /* total number of arguments */ 330 #ifdef _LP64 331 unsigned short sy_flags; /* various flags as defined below */ 332 #else 333 unsigned char sy_flags; /* various flags as defined below */ 334 #endif 335 int (*sy_call)(); /* argp, rvalp-style handler */ 336 krwlock_t *sy_lock; /* lock for loadable system calls */ 337 int64_t (*sy_callc)(); /* C-style call hander or wrapper */ 338 }; 339 340 extern struct sysent sysent[]; 341 #ifdef _SYSCALL32_IMPL 342 extern struct sysent sysent32[]; 343 #endif 344 345 extern struct sysent nosys_ent; /* entry for invalid system call */ 346 347 #define NSYSCALL 256 /* number of system calls */ 348 349 #define LOADABLE_SYSCALL(s) (s->sy_flags & SE_LOADABLE) 350 #define LOADED_SYSCALL(s) (s->sy_flags & SE_LOADED) 351 352 /* 353 * sy_flags values 354 * Values 1, 2, and 4 were used previously for SETJUMP, ASYNC, and IOSYS. 355 */ 356 #define SE_32RVAL1 0x0 /* handler returns int32_t in rval1 */ 357 #define SE_32RVAL2 0x1 /* handler returns int32_t in rval2 */ 358 #define SE_64RVAL 0x2 /* handler returns int64_t in rvals */ 359 #define SE_RVAL_MASK 0x3 /* mask of rval_t bits */ 360 361 #define SE_LOADABLE 0x08 /* syscall is loadable */ 362 #define SE_LOADED 0x10 /* syscall is completely loaded */ 363 #define SE_NOUNLOAD 0x20 /* syscall never needs unload */ 364 #define SE_ARGC 0x40 /* syscall takes C-style args */ 365 366 /* 367 * Structure of the return-value parameter passed by reference to 368 * system entries. 369 */ 370 union rval { 371 struct { 372 int r_v1; 373 int r_v2; 374 } r_v; 375 off_t r_off; 376 offset_t r_offset; 377 time_t r_time; 378 int64_t r_vals; 379 }; 380 #define r_val1 r_v.r_v1 381 #define r_val2 r_v.r_v2 382 383 typedef union rval rval_t; 384 385 #if defined(_KERNEL) || defined(_FAKE_KERNEL) 386 387 extern void reset_syscall_args(void); 388 extern int save_syscall_args(void); 389 extern uint_t get_syscall_args(klwp_t *lwp, long *argp, int *nargsp); 390 #ifdef _SYSCALL32_IMPL 391 extern uint_t get_syscall32_args(klwp_t *lwp, int *argp, int *nargp); 392 #endif 393 394 extern uint_t set_errno(uint_t error); 395 #pragma rarely_called(set_errno) 396 397 extern int64_t syscall_ap(void); 398 extern int64_t loadable_syscall(long, long, long, long, long, long, long, long); 399 extern int64_t nosys(void); 400 401 extern void swtch(void); 402 403 extern uint_t kcpc_key; /* TSD key for performance counter context */ 404 405 /* 406 * initname holds the path to init and is used as a point of rendezvous 407 * between krtld (which processes the boot arguments) and the kernel. 408 */ 409 #define INITNAME_SZ 32 410 extern char initname[INITNAME_SZ]; 411 412 /* 413 * initargs holds the arguments to init (such as -v, -s, -r, -m verbose) and 414 * is a point of rendezvous between krtld (which processes the boot arguments) 415 * and the kernel. 416 */ 417 extern char initargs[BOOTARGS_MAX]; 418 419 extern int exec_init(const char *, const char *); 420 extern int start_init_common(void); 421 422 #endif /* _KERNEL */ 423 424 #if defined(_KERNEL) || defined(_FAKE_KERNEL) || defined(_BOOT) 425 426 size_t strlcat(char *, const char *, size_t); 427 size_t strlen(const char *) __PURE; 428 char *strcat(char *, const char *); 429 char *strncat(char *, const char *, size_t); 430 char *strcpy(char *, const char *); 431 char *strncpy(char *, const char *, size_t); 432 433 extern size_t strlcpy(char *, const char *, size_t); 434 extern size_t strspn(const char *, const char *); 435 extern size_t strcspn(const char *, const char *); 436 extern char *strdup(const char *); 437 extern void strfree(char *); 438 439 /* Need to be consistent with <string.h> C++ definitions */ 440 #if __cplusplus >= 199711L 441 extern const char *strchr(const char *, int); 442 #ifndef _STRCHR_INLINE 443 #define _STRCHR_INLINE 444 extern "C++" { 445 inline char *strchr(char *__s, int __c) { 446 return (char *)strchr((const char *)__s, __c); 447 } 448 } 449 #endif /* _STRCHR_INLINE */ 450 extern const char *strrchr(const char *, int); 451 #ifndef _STRRCHR_INLINE 452 #define _STRRCHR_INLINE 453 extern "C++" { 454 inline char *strrchr(char *__s, int __c) { 455 return (char *)strrchr((const char *)__s, __c); 456 } 457 } 458 #endif /* _STRRCHR_INLINE */ 459 extern const char *strstr(const char *, const char *); 460 #ifndef _STRSTR_INLINE 461 #define _STRSTR_INLINE 462 extern "C++" { 463 inline char *strstr(char *__s1, const char *__s2) { 464 return (char *)strstr((const char *)__s1, __s2); 465 } 466 } 467 #endif /* _STRSTR_INLINE */ 468 #else /* __cplusplus >= 199711L */ 469 char *strchr(const char *, int); 470 char *strrchr(const char *, int); 471 char *strstr(const char *, const char *); 472 #endif /* __cplusplus >= 199711L */ 473 char *strnrchr(const char *, int, size_t); 474 int strcmp(const char *, const char *) __PURE; 475 int strncmp(const char *, const char *, size_t) __PURE; 476 int strcasecmp(const char *, const char *) __PURE; 477 int strncasecmp(const char *, const char *, size_t) __PURE; 478 /* Need to be consistent with <string.h> C++ definitions */ 479 #if __cplusplus >= 199711L 480 extern const char *strpbrk(const char *, const char *); 481 #ifndef _STRPBRK_INLINE 482 #define _STRPBRK_INLINE 483 extern "C++" { 484 inline char *strpbrk(char *__s1, const char *__s2) { 485 return (char *)strpbrk((const char *)__s1, __s2); 486 } 487 } 488 #endif /* _STRPBRK_INLINE */ 489 #else /* __cplusplus >= 199711L */ 490 char *strpbrk(const char *, const char *); 491 #endif /* __cplusplus >= 199711L */ 492 void bcopy(const void *, void *, size_t); 493 void bzero(void *, size_t); 494 495 extern void *memset(void *, int, size_t); 496 extern void *memcpy(void *, const void *, size_t); 497 extern void *memmove(void *, const void *, size_t); 498 extern int memcmp(const void *, const void *, size_t); 499 500 #ifdef __lint 501 extern int __lintzero; /* for spoofing lint */ 502 #else /* __lint */ 503 #define __lintzero 0 504 #endif /* __lint */ 505 #endif /* _KERNEL || _BOOT */ 506 507 #ifdef __cplusplus 508 } 509 #endif 510 511 #endif /* _SYS_SYSTM_H */