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