1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1988, 1991, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 *    may be used to endorse or promote products derived from this software
22 *    without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 *	@(#)systm.h	8.7 (Berkeley) 3/29/95
37 * $FreeBSD$
38 */
39
40#ifndef _SYS_SYSTM_H_
41#define	_SYS_SYSTM_H_
42
43#include <sys/cdefs.h>
44#include <machine/atomic.h>
45#include <machine/cpufunc.h>
46#include <sys/callout.h>
47#include <sys/queue.h>
48#include <sys/stdint.h>		/* for people using printf mainly */
49
50__NULLABILITY_PRAGMA_PUSH
51
52extern int cold;		/* nonzero if we are doing a cold boot */
53extern int suspend_blocked;	/* block suspend due to pending shutdown */
54extern int rebooting;		/* kern_reboot() has been called. */
55extern const char *panicstr;	/* panic message */
56extern bool panicked;
57#define	KERNEL_PANICKED()	__predict_false(panicked)
58extern char version[];		/* system version */
59extern char compiler_version[];	/* compiler version */
60extern char copyright[];	/* system copyright */
61extern int kstack_pages;	/* number of kernel stack pages */
62
63extern u_long pagesizes[];	/* supported page sizes */
64extern long physmem;		/* physical memory */
65extern long realmem;		/* 'real' memory */
66
67extern char *rootdevnames[2];	/* names of possible root devices */
68
69extern int boothowto;		/* reboot flags, from console subsystem */
70extern int bootverbose;		/* nonzero to print verbose messages */
71
72extern int maxusers;		/* system tune hint */
73extern int ngroups_max;		/* max # of supplemental groups */
74extern int vm_guest;		/* Running as virtual machine guest? */
75
76/*
77 * Detected virtual machine guest types. The intention is to expand
78 * and/or add to the VM_GUEST_VM type if specific VM functionality is
79 * ever implemented (e.g. vendor-specific paravirtualization features).
80 * Keep in sync with vm_guest_sysctl_names[].
81 */
82enum VM_GUEST { VM_GUEST_NO = 0, VM_GUEST_VM, VM_GUEST_XEN, VM_GUEST_HV,
83		VM_GUEST_VMWARE, VM_GUEST_KVM, VM_GUEST_BHYVE, VM_GUEST_VBOX,
84		VM_GUEST_PARALLELS, VM_LAST };
85
86/*
87 * These functions need to be declared before the KASSERT macro is invoked in
88 * !KASSERT_PANIC_OPTIONAL builds, so their declarations are sort of out of
89 * place compared to other function definitions in this header.  On the other
90 * hand, this header is a bit disorganized anyway.
91 */
92void	panic(const char *, ...) __dead2 __printflike(1, 2);
93void	vpanic(const char *, __va_list) __dead2 __printflike(1, 0);
94
95#if defined(WITNESS) || defined(INVARIANT_SUPPORT)
96#ifdef KASSERT_PANIC_OPTIONAL
97void	kassert_panic(const char *fmt, ...)  __printflike(1, 2);
98#else
99#define kassert_panic	panic
100#endif
101#endif
102
103#ifdef	INVARIANTS		/* The option is always available */
104#define	KASSERT(exp,msg) do {						\
105	if (__predict_false(!(exp)))					\
106		kassert_panic msg;					\
107} while (0)
108#define	VNASSERT(exp, vp, msg) do {					\
109	if (__predict_false(!(exp))) {					\
110		vn_printf(vp, "VNASSERT failed\n");			\
111		kassert_panic msg;					\
112	}								\
113} while (0)
114#else
115#define	KASSERT(exp,msg) do { \
116} while (0)
117
118#define	VNASSERT(exp, vp, msg) do { \
119} while (0)
120#endif
121
122#ifndef CTASSERT	/* Allow lint to override */
123#define	CTASSERT(x)	_Static_assert(x, "compile-time assertion failed")
124#endif
125
126#if defined(_KERNEL)
127#include <sys/param.h>		/* MAXCPU */
128#include <sys/pcpu.h>		/* curthread */
129#include <sys/kpilite.h>
130#endif
131
132/*
133 * Assert that a pointer can be loaded from memory atomically.
134 *
135 * This assertion enforces stronger alignment than necessary.  For example,
136 * on some architectures, atomicity for unaligned loads will depend on
137 * whether or not the load spans multiple cache lines.
138 */
139#define	ASSERT_ATOMIC_LOAD_PTR(var, msg)				\
140	KASSERT(sizeof(var) == sizeof(void *) &&			\
141	    ((uintptr_t)&(var) & (sizeof(void *) - 1)) == 0, msg)
142
143/*
144 * Assert that a thread is in critical(9) section.
145 */
146#define	CRITICAL_ASSERT(td)						\
147	KASSERT((td)->td_critnest >= 1, ("Not in critical section"));
148
149/*
150 * If we have already panic'd and this is the thread that called
151 * panic(), then don't block on any mutexes but silently succeed.
152 * Otherwise, the kernel will deadlock since the scheduler isn't
153 * going to run the thread that holds any lock we need.
154 */
155#define	SCHEDULER_STOPPED_TD(td)  ({					\
156	MPASS((td) == curthread);					\
157	__predict_false((td)->td_stopsched);				\
158})
159#define	SCHEDULER_STOPPED() SCHEDULER_STOPPED_TD(curthread)
160
161/*
162 * Align variables.
163 */
164#define	__read_mostly		__section(".data.read_mostly")
165#define	__read_frequently	__section(".data.read_frequently")
166#define	__exclusive_cache_line	__aligned(CACHE_LINE_SIZE) \
167				    __section(".data.exclusive_cache_line")
168/*
169 * XXX the hints declarations are even more misplaced than most declarations
170 * in this file, since they are needed in one file (per arch) and only used
171 * in two files.
172 * XXX most of these variables should be const.
173 */
174extern int osreldate;
175extern bool dynamic_kenv;
176extern struct mtx kenv_lock;
177extern char *kern_envp;
178extern char *md_envp;
179extern char static_env[];
180extern char static_hints[];	/* by config for now */
181
182extern char **kenvp;
183
184extern const void *zero_region;	/* address space maps to a zeroed page	*/
185
186extern int unmapped_buf_allowed;
187
188#ifdef __LP64__
189#define	IOSIZE_MAX		iosize_max()
190#define	DEVFS_IOSIZE_MAX	devfs_iosize_max()
191#else
192#define	IOSIZE_MAX		SSIZE_MAX
193#define	DEVFS_IOSIZE_MAX	SSIZE_MAX
194#endif
195
196/*
197 * General function declarations.
198 */
199
200struct inpcb;
201struct lock_object;
202struct malloc_type;
203struct mtx;
204struct proc;
205struct socket;
206struct thread;
207struct tty;
208struct ucred;
209struct uio;
210struct _jmp_buf;
211struct trapframe;
212struct eventtimer;
213
214int	setjmp(struct _jmp_buf *) __returns_twice;
215void	longjmp(struct _jmp_buf *, int) __dead2;
216int	dumpstatus(vm_offset_t addr, off_t count);
217int	nullop(void);
218int	eopnotsupp(void);
219int	ureadc(int, struct uio *);
220void	hashdestroy(void *, struct malloc_type *, u_long);
221void	*hashinit(int count, struct malloc_type *type, u_long *hashmask);
222void	*hashinit_flags(int count, struct malloc_type *type,
223    u_long *hashmask, int flags);
224#define	HASH_NOWAIT	0x00000001
225#define	HASH_WAITOK	0x00000002
226
227void	*phashinit(int count, struct malloc_type *type, u_long *nentries);
228void	*phashinit_flags(int count, struct malloc_type *type, u_long *nentries,
229    int flags);
230void	g_waitidle(void);
231
232void	cpu_boot(int);
233void	cpu_flush_dcache(void *, size_t);
234void	cpu_rootconf(void);
235void	critical_enter_KBI(void);
236void	critical_exit_KBI(void);
237void	critical_exit_preempt(void);
238void	init_param1(void);
239void	init_param2(long physpages);
240void	init_static_kenv(char *, size_t);
241void	tablefull(const char *);
242
243/*
244 * Allocate per-thread "current" state in the linuxkpi
245 */
246extern int (*lkpi_alloc_current)(struct thread *, int);
247int linux_alloc_current_noop(struct thread *, int);
248
249
250#if defined(KLD_MODULE) || defined(KTR_CRITICAL) || !defined(_KERNEL) || defined(GENOFFSET)
251#define critical_enter() critical_enter_KBI()
252#define critical_exit() critical_exit_KBI()
253#else
254static __inline void
255critical_enter(void)
256{
257	struct thread_lite *td;
258
259	td = (struct thread_lite *)curthread;
260	td->td_critnest++;
261	__compiler_membar();
262}
263
264static __inline void
265critical_exit(void)
266{
267	struct thread_lite *td;
268
269	td = (struct thread_lite *)curthread;
270	KASSERT(td->td_critnest != 0,
271	    ("critical_exit: td_critnest == 0"));
272	__compiler_membar();
273	td->td_critnest--;
274	__compiler_membar();
275	if (__predict_false(td->td_owepreempt))
276		critical_exit_preempt();
277
278}
279#endif
280
281
282#ifdef  EARLY_PRINTF
283typedef void early_putc_t(int ch);
284extern early_putc_t *early_putc;
285#endif
286int	kvprintf(char const *, void (*)(int, void*), void *, int,
287	    __va_list) __printflike(1, 0);
288void	log(int, const char *, ...) __printflike(2, 3);
289void	log_console(struct uio *);
290void	vlog(int, const char *, __va_list) __printflike(2, 0);
291int	asprintf(char **ret, struct malloc_type *mtp, const char *format,
292	    ...) __printflike(3, 4);
293int	printf(const char *, ...) __printflike(1, 2);
294int	snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
295int	sprintf(char *buf, const char *, ...) __printflike(2, 3);
296int	uprintf(const char *, ...) __printflike(1, 2);
297int	vprintf(const char *, __va_list) __printflike(1, 0);
298int	vasprintf(char **ret, struct malloc_type *mtp, const char *format,
299	    __va_list ap) __printflike(3, 0);
300int	vsnprintf(char *, size_t, const char *, __va_list) __printflike(3, 0);
301int	vsnrprintf(char *, size_t, int, const char *, __va_list) __printflike(4, 0);
302int	vsprintf(char *buf, const char *, __va_list) __printflike(2, 0);
303int	sscanf(const char *, char const * _Nonnull, ...) __scanflike(2, 3);
304int	vsscanf(const char * _Nonnull, char const * _Nonnull, __va_list)  __scanflike(2, 0);
305long	strtol(const char *, char **, int);
306u_long	strtoul(const char *, char **, int);
307quad_t	strtoq(const char *, char **, int);
308u_quad_t strtouq(const char *, char **, int);
309void	tprintf(struct proc *p, int pri, const char *, ...) __printflike(3, 4);
310void	vtprintf(struct proc *, int, const char *, __va_list) __printflike(3, 0);
311void	hexdump(const void *ptr, int length, const char *hdr, int flags);
312#define	HD_COLUMN_MASK	0xff
313#define	HD_DELIM_MASK	0xff00
314#define	HD_OMIT_COUNT	(1 << 16)
315#define	HD_OMIT_HEX	(1 << 17)
316#define	HD_OMIT_CHARS	(1 << 18)
317
318#define ovbcopy(f, t, l) bcopy((f), (t), (l))
319void	bcopy(const void * _Nonnull from, void * _Nonnull to, size_t len);
320void	bzero(void * _Nonnull buf, size_t len);
321void	explicit_bzero(void * _Nonnull, size_t);
322int	bcmp(const void *b1, const void *b2, size_t len);
323
324void	*memset(void * _Nonnull buf, int c, size_t len);
325void	*memcpy(void * _Nonnull to, const void * _Nonnull from, size_t len);
326void	*memmove(void * _Nonnull dest, const void * _Nonnull src, size_t n);
327int	memcmp(const void *b1, const void *b2, size_t len);
328
329#ifdef KCSAN
330void	*kcsan_memset(void *, int, size_t);
331void	*kcsan_memcpy(void *, const void *, size_t);
332void	*kcsan_memmove(void *, const void *, size_t);
333int	kcsan_memcmp(const void *, const void *, size_t);
334#define bcopy(from, to, len) kcsan_memmove((to), (from), (len))
335#define bzero(buf, len) kcsan_memset((buf), 0, (len))
336#define bcmp(b1, b2, len) kcsan_memcmp((b1), (b2), (len))
337#define memset(buf, c, len) kcsan_memset((buf), (c), (len))
338#define memcpy(to, from, len) kcsan_memcpy((to), (from), (len))
339#define memmove(dest, src, n) kcsan_memmove((dest), (src), (n))
340#define memcmp(b1, b2, len) kcsan_memcmp((b1), (b2), (len))
341#else
342#define bcopy(from, to, len) __builtin_memmove((to), (from), (len))
343#define bzero(buf, len) __builtin_memset((buf), 0, (len))
344#define bcmp(b1, b2, len) __builtin_memcmp((b1), (b2), (len))
345#define memset(buf, c, len) __builtin_memset((buf), (c), (len))
346#define memcpy(to, from, len) __builtin_memcpy((to), (from), (len))
347#define memmove(dest, src, n) __builtin_memmove((dest), (src), (n))
348#define memcmp(b1, b2, len) __builtin_memcmp((b1), (b2), (len))
349#endif
350
351void	*memset_early(void * _Nonnull buf, int c, size_t len);
352#define bzero_early(buf, len) memset_early((buf), 0, (len))
353void	*memcpy_early(void * _Nonnull to, const void * _Nonnull from, size_t len);
354void	*memmove_early(void * _Nonnull dest, const void * _Nonnull src, size_t n);
355#define bcopy_early(from, to, len) memmove_early((to), (from), (len))
356
357int	copystr(const void * _Nonnull __restrict kfaddr,
358	    void * _Nonnull __restrict kdaddr, size_t len,
359	    size_t * __restrict lencopied);
360int	copyinstr(const void * __restrict udaddr,
361	    void * _Nonnull __restrict kaddr, size_t len,
362	    size_t * __restrict lencopied);
363int	copyin(const void * __restrict udaddr,
364	    void * _Nonnull __restrict kaddr, size_t len);
365int	copyin_nofault(const void * __restrict udaddr,
366	    void * _Nonnull __restrict kaddr, size_t len);
367int	copyout(const void * _Nonnull __restrict kaddr,
368	    void * __restrict udaddr, size_t len);
369int	copyout_nofault(const void * _Nonnull __restrict kaddr,
370	    void * __restrict udaddr, size_t len);
371
372#ifdef KCSAN
373int	kcsan_copystr(const void *, void *, size_t, size_t *);
374int	kcsan_copyin(const void *, void *, size_t);
375int	kcsan_copyinstr(const void *, void *, size_t, size_t *);
376int	kcsan_copyout(const void *, void *, size_t);
377#define	copystr(kf, k, l, lc) kcsan_copystr((kf), (k), (l), (lc))
378#define	copyin(u, k, l) kcsan_copyin((u), (k), (l))
379#define	copyinstr(u, k, l, lc) kcsan_copyinstr((u), (k), (l), (lc))
380#define	copyout(k, u, l) kcsan_copyout((k), (u), (l))
381#endif
382
383int	fubyte(volatile const void *base);
384long	fuword(volatile const void *base);
385int	fuword16(volatile const void *base);
386int32_t	fuword32(volatile const void *base);
387int64_t	fuword64(volatile const void *base);
388int	fueword(volatile const void *base, long *val);
389int	fueword32(volatile const void *base, int32_t *val);
390int	fueword64(volatile const void *base, int64_t *val);
391int	subyte(volatile void *base, int byte);
392int	suword(volatile void *base, long word);
393int	suword16(volatile void *base, int word);
394int	suword32(volatile void *base, int32_t word);
395int	suword64(volatile void *base, int64_t word);
396uint32_t casuword32(volatile uint32_t *base, uint32_t oldval, uint32_t newval);
397u_long	casuword(volatile u_long *p, u_long oldval, u_long newval);
398int	casueword32(volatile uint32_t *base, uint32_t oldval, uint32_t *oldvalp,
399	    uint32_t newval);
400int	casueword(volatile u_long *p, u_long oldval, u_long *oldvalp,
401	    u_long newval);
402
403void	realitexpire(void *);
404
405int	sysbeep(int hertz, int period);
406
407void	hardclock(int cnt, int usermode);
408void	hardclock_sync(int cpu);
409void	softclock(void *);
410void	statclock(int cnt, int usermode);
411void	profclock(int cnt, int usermode, uintfptr_t pc);
412
413int	hardclockintr(void);
414
415void	startprofclock(struct proc *);
416void	stopprofclock(struct proc *);
417void	cpu_startprofclock(void);
418void	cpu_stopprofclock(void);
419void	suspendclock(void);
420void	resumeclock(void);
421sbintime_t 	cpu_idleclock(void);
422void	cpu_activeclock(void);
423void	cpu_new_callout(int cpu, sbintime_t bt, sbintime_t bt_opt);
424void	cpu_et_frequency(struct eventtimer *et, uint64_t newfreq);
425extern int	cpu_disable_c2_sleep;
426extern int	cpu_disable_c3_sleep;
427
428char	*kern_getenv(const char *name);
429void	freeenv(char *env);
430int	getenv_int(const char *name, int *data);
431int	getenv_uint(const char *name, unsigned int *data);
432int	getenv_long(const char *name, long *data);
433int	getenv_ulong(const char *name, unsigned long *data);
434int	getenv_string(const char *name, char *data, int size);
435int	getenv_int64(const char *name, int64_t *data);
436int	getenv_uint64(const char *name, uint64_t *data);
437int	getenv_quad(const char *name, quad_t *data);
438int	kern_setenv(const char *name, const char *value);
439int	kern_unsetenv(const char *name);
440int	testenv(const char *name);
441
442int	getenv_array(const char *name, void *data, int size, int *psize,
443    int type_size, bool allow_signed);
444#define	GETENV_UNSIGNED	false	/* negative numbers not allowed */
445#define	GETENV_SIGNED	true	/* negative numbers allowed */
446
447typedef uint64_t (cpu_tick_f)(void);
448void set_cputicker(cpu_tick_f *func, uint64_t freq, unsigned var);
449extern cpu_tick_f *cpu_ticks;
450uint64_t cpu_tickrate(void);
451uint64_t cputick2usec(uint64_t tick);
452
453#ifdef APM_FIXUP_CALLTODO
454struct timeval;
455void	adjust_timeout_calltodo(struct timeval *time_change);
456#endif /* APM_FIXUP_CALLTODO */
457
458#include <sys/libkern.h>
459
460/* Initialize the world */
461void	consinit(void);
462void	cpu_initclocks(void);
463void	cpu_initclocks_bsp(void);
464void	cpu_initclocks_ap(void);
465void	usrinfoinit(void);
466
467/* Finalize the world */
468void	kern_reboot(int) __dead2;
469void	shutdown_nice(int);
470
471/* Stubs for obsolete functions that used to be for interrupt management */
472static __inline intrmask_t	splbio(void)		{ return 0; }
473static __inline intrmask_t	splcam(void)		{ return 0; }
474static __inline intrmask_t	splclock(void)		{ return 0; }
475static __inline intrmask_t	splhigh(void)		{ return 0; }
476static __inline intrmask_t	splimp(void)		{ return 0; }
477static __inline intrmask_t	splnet(void)		{ return 0; }
478static __inline intrmask_t	spltty(void)		{ return 0; }
479static __inline void		splx(intrmask_t ipl __unused)	{ return; }
480
481/*
482 * Common `proc' functions are declared here so that proc.h can be included
483 * less often.
484 */
485int	_sleep(const void * _Nonnull chan, struct lock_object *lock, int pri,
486	   const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
487#define	msleep(chan, mtx, pri, wmesg, timo)				\
488	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg),		\
489	    tick_sbt * (timo), 0, C_HARDCLOCK)
490#define	msleep_sbt(chan, mtx, pri, wmesg, bt, pr, flags)		\
491	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), (bt), (pr),	\
492	    (flags))
493int	msleep_spin_sbt(const void * _Nonnull chan, struct mtx *mtx,
494	    const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
495#define	msleep_spin(chan, mtx, wmesg, timo)				\
496	msleep_spin_sbt((chan), (mtx), (wmesg), tick_sbt * (timo),	\
497	    0, C_HARDCLOCK)
498int	pause_sbt(const char *wmesg, sbintime_t sbt, sbintime_t pr,
499	    int flags);
500#define	pause(wmesg, timo)						\
501	pause_sbt((wmesg), tick_sbt * (timo), 0, C_HARDCLOCK)
502#define	pause_sig(wmesg, timo)						\
503	pause_sbt((wmesg), tick_sbt * (timo), 0, C_HARDCLOCK | C_CATCH)
504#define	tsleep(chan, pri, wmesg, timo)					\
505	_sleep((chan), NULL, (pri), (wmesg), tick_sbt * (timo),		\
506	    0, C_HARDCLOCK)
507#define	tsleep_sbt(chan, pri, wmesg, bt, pr, flags)			\
508	_sleep((chan), NULL, (pri), (wmesg), (bt), (pr), (flags))
509void	wakeup(const void *chan);
510void	wakeup_one(const void *chan);
511void	wakeup_any(const void *chan);
512
513/*
514 * Common `struct cdev *' stuff are declared here to avoid #include poisoning
515 */
516
517struct cdev;
518dev_t dev2udev(struct cdev *x);
519const char *devtoname(struct cdev *cdev);
520
521#ifdef __LP64__
522size_t	devfs_iosize_max(void);
523size_t	iosize_max(void);
524#endif
525
526int poll_no_poll(int events);
527
528/* XXX: Should be void nanodelay(u_int nsec); */
529void	DELAY(int usec);
530
531/* Root mount holdback API */
532struct root_hold_token {
533	int				flags;
534	const char			*who;
535	TAILQ_ENTRY(root_hold_token)	list;
536};
537
538struct root_hold_token *root_mount_hold(const char *identifier);
539void root_mount_hold_token(const char *identifier, struct root_hold_token *h);
540void root_mount_rel(struct root_hold_token *h);
541int root_mounted(void);
542
543
544/*
545 * Unit number allocation API. (kern/subr_unit.c)
546 */
547struct unrhdr;
548struct unrhdr *new_unrhdr(int low, int high, struct mtx *mutex);
549void init_unrhdr(struct unrhdr *uh, int low, int high, struct mtx *mutex);
550void delete_unrhdr(struct unrhdr *uh);
551void clear_unrhdr(struct unrhdr *uh);
552void clean_unrhdr(struct unrhdr *uh);
553void clean_unrhdrl(struct unrhdr *uh);
554int alloc_unr(struct unrhdr *uh);
555int alloc_unr_specific(struct unrhdr *uh, u_int item);
556int alloc_unrl(struct unrhdr *uh);
557void free_unr(struct unrhdr *uh, u_int item);
558
559#ifndef __LP64__
560#define UNR64_LOCKED
561#endif
562
563struct unrhdr64 {
564        uint64_t	counter;
565};
566
567static __inline void
568new_unrhdr64(struct unrhdr64 *unr64, uint64_t low)
569{
570
571	unr64->counter = low;
572}
573
574#ifdef UNR64_LOCKED
575uint64_t alloc_unr64(struct unrhdr64 *);
576#else
577static __inline uint64_t
578alloc_unr64(struct unrhdr64 *unr64)
579{
580
581	return (atomic_fetchadd_64(&unr64->counter, 1));
582}
583#endif
584
585void	intr_prof_stack_use(struct thread *td, struct trapframe *frame);
586
587void counted_warning(unsigned *counter, const char *msg);
588
589/*
590 * APIs to manage deprecation and obsolescence.
591 */
592struct device;
593void _gone_in(int major, const char *msg);
594void _gone_in_dev(struct device *dev, int major, const char *msg);
595#ifdef NO_OBSOLETE_CODE
596#define __gone_ok(m, msg)					 \
597	_Static_assert(m < P_OSREL_MAJOR(__FreeBSD_version)),	 \
598	    "Obsolete code: " msg);
599#else
600#define	__gone_ok(m, msg)
601#endif
602#define gone_in(major, msg)		__gone_ok(major, msg) _gone_in(major, msg)
603#define gone_in_dev(dev, major, msg)	__gone_ok(major, msg) _gone_in_dev(dev, major, msg)
604
605__NULLABILITY_PRAGMA_POP
606
607#endif /* !_SYS_SYSTM_H_ */
608