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