1/* $NetBSD: libkern.h,v 1.124 2016/07/07 06:55:43 msaitoh Exp $ */
2
3/*-
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * @(#)libkern.h 8.2 (Berkeley) 8/5/94
32 */
33
34#ifndef _LIB_LIBKERN_LIBKERN_H_
35#define _LIB_LIBKERN_LIBKERN_H_
36
37#ifdef _KERNEL_OPT
38#include "opt_diagnostic.h"
39#endif
40
41#include <sys/types.h>
42#include <sys/inttypes.h>
43#include <sys/null.h>
44
45#ifndef LIBKERN_INLINE
46#define LIBKERN_INLINE static __inline
47#define LIBKERN_BODY
48#endif
49
50LIBKERN_INLINE int imax(int, int) __unused;
51LIBKERN_INLINE int imin(int, int) __unused;
52LIBKERN_INLINE u_int max(u_int, u_int) __unused;
53LIBKERN_INLINE u_int min(u_int, u_int) __unused;
54LIBKERN_INLINE long lmax(long, long) __unused;
55LIBKERN_INLINE long lmin(long, long) __unused;
56LIBKERN_INLINE u_long ulmax(u_long, u_long) __unused;
57LIBKERN_INLINE u_long ulmin(u_long, u_long) __unused;
58LIBKERN_INLINE int abs(int) __unused;
59LIBKERN_INLINE long labs(long) __unused;
60LIBKERN_INLINE long long llabs(long long) __unused;
61LIBKERN_INLINE intmax_t imaxabs(intmax_t) __unused;
62
63LIBKERN_INLINE int isspace(int) __unused;
64LIBKERN_INLINE int isascii(int) __unused;
65LIBKERN_INLINE int isupper(int) __unused;
66LIBKERN_INLINE int islower(int) __unused;
67LIBKERN_INLINE int isalpha(int) __unused;
68LIBKERN_INLINE int isalnum(int) __unused;
69LIBKERN_INLINE int isdigit(int) __unused;
70LIBKERN_INLINE int isxdigit(int) __unused;
71LIBKERN_INLINE int iscntrl(int) __unused;
72LIBKERN_INLINE int isgraph(int) __unused;
73LIBKERN_INLINE int isprint(int) __unused;
74LIBKERN_INLINE int ispunct(int) __unused;
75LIBKERN_INLINE int toupper(int) __unused;
76LIBKERN_INLINE int tolower(int) __unused;
77
78#ifdef LIBKERN_BODY
79LIBKERN_INLINE int
80imax(int a, int b)
81{
82 return (a > b ? a : b);
83}
84LIBKERN_INLINE int
85imin(int a, int b)
86{
87 return (a < b ? a : b);
88}
89LIBKERN_INLINE long
90lmax(long a, long b)
91{
92 return (a > b ? a : b);
93}
94LIBKERN_INLINE long
95lmin(long a, long b)
96{
97 return (a < b ? a : b);
98}
99LIBKERN_INLINE u_int
100max(u_int a, u_int b)
101{
102 return (a > b ? a : b);
103}
104LIBKERN_INLINE u_int
105min(u_int a, u_int b)
106{
107 return (a < b ? a : b);
108}
109LIBKERN_INLINE u_long
110ulmax(u_long a, u_long b)
111{
112 return (a > b ? a : b);
113}
114LIBKERN_INLINE u_long
115ulmin(u_long a, u_long b)
116{
117 return (a < b ? a : b);
118}
119
120LIBKERN_INLINE int
121abs(int j)
122{
123 return(j < 0 ? -j : j);
124}
125
126LIBKERN_INLINE long
127labs(long j)
128{
129 return(j < 0 ? -j : j);
130}
131
132LIBKERN_INLINE long long
133llabs(long long j)
134{
135 return(j < 0 ? -j : j);
136}
137
138LIBKERN_INLINE intmax_t
139imaxabs(intmax_t j)
140{
141 return(j < 0 ? -j : j);
142}
143
144LIBKERN_INLINE int
145isspace(int ch)
146{
147 return (ch == ' ' || (ch >= '\t' && ch <= '\r'));
148}
149
150LIBKERN_INLINE int
151isascii(int ch)
152{
153 return ((ch & ~0x7f) == 0);
154}
155
156LIBKERN_INLINE int
157isupper(int ch)
158{
159 return (ch >= 'A' && ch <= 'Z');
160}
161
162LIBKERN_INLINE int
163islower(int ch)
164{
165 return (ch >= 'a' && ch <= 'z');
166}
167
168LIBKERN_INLINE int
169isalpha(int ch)
170{
171 return (isupper(ch) || islower(ch));
172}
173
174LIBKERN_INLINE int
175isalnum(int ch)
176{
177 return (isalpha(ch) || isdigit(ch));
178}
179
180LIBKERN_INLINE int
181isdigit(int ch)
182{
183 return (ch >= '0' && ch <= '9');
184}
185
186LIBKERN_INLINE int
187isxdigit(int ch)
188{
189 return (isdigit(ch) ||
190 (ch >= 'A' && ch <= 'F') ||
191 (ch >= 'a' && ch <= 'f'));
192}
193
194LIBKERN_INLINE int
195iscntrl(int ch)
196{
197 return ((ch >= 0x00 && ch <= 0x1F) || ch == 0x7F);
198}
199
200LIBKERN_INLINE int
201isgraph(int ch)
202{
203 return (ch != ' ' && isprint(ch));
204}
205
206LIBKERN_INLINE int
207isprint(int ch)
208{
209 return (ch >= 0x20 && ch <= 0x7E);
210}
211
212LIBKERN_INLINE int
213ispunct(int ch)
214{
215 return (isprint(ch) && ch != ' ' && !isalnum(ch));
216}
217
218LIBKERN_INLINE int
219toupper(int ch)
220{
221 if (islower(ch))
222 return (ch - 0x20);
223 return (ch);
224}
225
226LIBKERN_INLINE int
227tolower(int ch)
228{
229 if (isupper(ch))
230 return (ch + 0x20);
231 return (ch);
232}
233#endif
234
235#define __NULL_STMT do { } while (/* CONSTCOND */ 0)
236
237#define __KASSERTSTR "kernel %sassertion \"%s\" failed: file \"%s\", line %d "
238
239#ifdef NDEBUG /* tradition! */
240#define assert(e) ((void)0)
241#else
242#define assert(e) (__predict_true((e)) ? (void)0 : \
243 kern_assert(__KASSERTSTR, "", #e, __FILE__, __LINE__))
244#endif
245
246#ifdef __COVERITY__
247#ifndef DIAGNOSTIC
248#define DIAGNOSTIC
249#endif
250#endif
251
252#ifndef CTASSERT
253#define CTASSERT(x) __CTASSERT(x)
254#endif
255#ifndef CTASSERT_SIGNED
256#define CTASSERT_SIGNED(x) __CTASSERT(((typeof(x))-1) < 0)
257#endif
258#ifndef CTASSERT_UNSIGNED
259#define CTASSERT_UNSIGNED(x) __CTASSERT(((typeof(x))-1) >= 0)
260#endif
261
262#ifndef DIAGNOSTIC
263#define _DIAGASSERT(a) (void)0
264#ifdef lint
265#define KASSERTMSG(e, msg, ...) /* NOTHING */
266#define KASSERT(e) /* NOTHING */
267#else /* !lint */
268#define KASSERTMSG(e, msg, ...) ((void)0)
269#define KASSERT(e) ((void)0)
270#endif /* !lint */
271#else /* DIAGNOSTIC */
272#define _DIAGASSERT(a) assert(a)
273#define KASSERTMSG(e, msg, ...) \
274 (__predict_true((e)) ? (void)0 : \
275 kern_assert(__KASSERTSTR msg, "diagnostic ", #e, \
276 __FILE__, __LINE__, ## __VA_ARGS__))
277
278#define KASSERT(e) (__predict_true((e)) ? (void)0 : \
279 kern_assert(__KASSERTSTR, "diagnostic ", #e, \
280 __FILE__, __LINE__))
281#endif
282
283#ifndef DEBUG
284#ifdef lint
285#define KDASSERTMSG(e,msg, ...) /* NOTHING */
286#define KDASSERT(e) /* NOTHING */
287#else /* lint */
288#define KDASSERTMSG(e,msg, ...) ((void)0)
289#define KDASSERT(e) ((void)0)
290#endif /* lint */
291#else
292#define KDASSERTMSG(e, msg, ...) \
293 (__predict_true((e)) ? (void)0 : \
294 kern_assert(__KASSERTSTR msg, "debugging ", #e, \
295 __FILE__, __LINE__, ## __VA_ARGS__))
296
297#define KDASSERT(e) (__predict_true((e)) ? (void)0 : \
298 kern_assert(__KASSERTSTR, "debugging ", #e, \
299 __FILE__, __LINE__))
300#endif
301
302/*
303 * XXX: For compatibility we use SMALL_RANDOM by default.
304 */
305#define SMALL_RANDOM
306
307#ifndef offsetof
308#if __GNUC_PREREQ__(4, 0)
309#define offsetof(type, member) __builtin_offsetof(type, member)
310#else
311#define offsetof(type, member) \
312 ((size_t)(unsigned long)(&(((type *)0)->member)))
313#endif
314#endif
315
316/*
317 * Return the container of an embedded struct. Given x = &c->f,
318 * container_of(x, T, f) yields c, where T is the type of c. Example:
319 *
320 * struct foo { ... };
321 * struct bar {
322 * int b_x;
323 * struct foo b_foo;
324 * ...
325 * };
326 *
327 * struct bar b;
328 * struct foo *fp = b.b_foo;
329 *
330 * Now we can get at b from fp by:
331 *
332 * struct bar *bp = container_of(fp, struct bar, b_foo);
333 *
334 * The 0*sizeof((PTR) - ...) causes the compiler to warn if the type of
335 * *fp does not match the type of struct bar::b_foo.
336 * We skip the validation for coverity runs to avoid warnings.
337 */
338#ifdef __COVERITY__
339#define __validate_container_of(PTR, TYPE, FIELD) 0
340#define __validate_const_container_of(PTR, TYPE, FIELD) 0
341#else
342#define __validate_container_of(PTR, TYPE, FIELD) \
343 (0 * sizeof((PTR) - &((TYPE *)(((char *)(PTR)) - \
344 offsetof(TYPE, FIELD)))->FIELD))
345#define __validate_const_container_of(PTR, TYPE, FIELD) \
346 (0 * sizeof((PTR) - &((const TYPE *)(((const char *)(PTR)) - \
347 offsetof(TYPE, FIELD)))->FIELD))
348#endif
349
350#define container_of(PTR, TYPE, FIELD) \
351 ((TYPE *)(((char *)(PTR)) - offsetof(TYPE, FIELD)) \
352 + __validate_container_of(PTR, TYPE, FIELD))
353#define const_container_of(PTR, TYPE, FIELD) \
354 ((const TYPE *)(((const char *)(PTR)) - offsetof(TYPE, FIELD)) \
355 + __validate_const_container_of(PTR, TYPE, FIELD))
356
357#define MTPRNG_RLEN 624
358struct mtprng_state {
359 unsigned int mt_idx;
360 uint32_t mt_elem[MTPRNG_RLEN];
361 uint32_t mt_count;
362 uint32_t mt_sparse[3];
363};
364
365/* Prototypes for which GCC built-ins exist. */
366void *memcpy(void *, const void *, size_t);
367int memcmp(const void *, const void *, size_t);
368void *memset(void *, int, size_t);
369#if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
370#define memcpy(d, s, l) __builtin_memcpy(d, s, l)
371#define memcmp(a, b, l) __builtin_memcmp(a, b, l)
372#endif
373#if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
374#define memset(d, v, l) __builtin_memset(d, v, l)
375#endif
376
377char *strcpy(char *, const char *);
378int strcmp(const char *, const char *);
379size_t strlen(const char *);
380size_t strnlen(const char *, size_t);
381char *strsep(char **, const char *);
382#if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
383#define strcpy(d, s) __builtin_strcpy(d, s)
384#define strcmp(a, b) __builtin_strcmp(a, b)
385#define strlen(a) __builtin_strlen(a)
386#endif
387
388/* Functions for which we always use built-ins. */
389#ifdef __GNUC__
390#define alloca(s) __builtin_alloca(s)
391#endif
392
393/* These exist in GCC 3.x, but we don't bother. */
394char *strcat(char *, const char *);
395size_t strcspn(const char *, const char *);
396char *strncpy(char *, const char *, size_t);
397char *strncat(char *, const char *, size_t);
398int strncmp(const char *, const char *, size_t);
399char *strchr(const char *, int);
400char *strrchr(const char *, int);
401char *strstr(const char *, const char *);
402char *strpbrk(const char *, const char *);
403size_t strspn(const char *, const char *);
404
405/*
406 * ffs is an instruction on vax.
407 */
408int ffs(int);
409#if __GNUC_PREREQ__(2, 95) && (!defined(__vax__) || __GNUC_PREREQ__(4,1))
410#define ffs(x) __builtin_ffs(x)
411#endif
412
413void kern_assert(const char *, ...)
414 __attribute__((__format__(__printf__, 1, 2)));
415u_int32_t
416 inet_addr(const char *);
417struct in_addr;
418int inet_aton(const char *, struct in_addr *);
419char *intoa(u_int32_t);
420#define inet_ntoa(a) intoa((a).s_addr)
421void *memchr(const void *, int, size_t);
422void *memmove(void *, const void *, size_t);
423int pmatch(const char *, const char *, const char **);
424#ifndef SMALL_RANDOM
425void srandom(unsigned long);
426char *initstate(unsigned long, char *, size_t);
427char *setstate(char *);
428#endif /* SMALL_RANDOM */
429long random(void);
430void mi_vector_hash(const void * __restrict, size_t, uint32_t,
431 uint32_t[3]);
432void mtprng_init32(struct mtprng_state *, uint32_t);
433void mtprng_initarray(struct mtprng_state *, const uint32_t *, size_t);
434uint32_t mtprng_rawrandom(struct mtprng_state *);
435uint32_t mtprng_random(struct mtprng_state *);
436int scanc(u_int, const u_char *, const u_char *, int);
437int skpc(int, size_t, u_char *);
438int strcasecmp(const char *, const char *);
439size_t strlcpy(char *, const char *, size_t);
440size_t strlcat(char *, const char *, size_t);
441int strncasecmp(const char *, const char *, size_t);
442u_long strtoul(const char *, char **, int);
443long long strtoll(const char *, char **, int);
444unsigned long long strtoull(const char *, char **, int);
445intmax_t strtoimax(const char *, char **, int);
446uintmax_t strtoumax(const char *, char **, int);
447intmax_t strtoi(const char * __restrict, char ** __restrict, int, intmax_t,
448 intmax_t, int *);
449uintmax_t strtou(const char * __restrict, char ** __restrict, int, uintmax_t,
450 uintmax_t, int *);
451
452int snprintb(char *, size_t, const char *, uint64_t);
453int snprintb_m(char *, size_t, const char *, uint64_t, size_t);
454int kheapsort(void *, size_t, size_t, int (*)(const void *, const void *),
455 void *);
456uint32_t crc32(uint32_t, const uint8_t *, size_t);
457#if __GNUC_PREREQ__(4, 5) \
458 && (defined(__alpha_cix__) || defined(__mips_popcount))
459#define popcount __builtin_popcount
460#define popcountl __builtin_popcountl
461#define popcountll __builtin_popcountll
462#define popcount32 __builtin_popcount
463#define popcount64 __builtin_popcountll
464#else
465unsigned int popcount(unsigned int) __constfunc;
466unsigned int popcountl(unsigned long) __constfunc;
467unsigned int popcountll(unsigned long long) __constfunc;
468unsigned int popcount32(uint32_t) __constfunc;
469unsigned int popcount64(uint64_t) __constfunc;
470#endif
471
472void *explicit_memset(void *, int, size_t);
473int consttime_memequal(const void *, const void *, size_t);
474int strnvisx(char *, size_t, const char *, size_t, int);
475#define VIS_OCTAL 0x01
476#define VIS_SAFE 0x20
477#define VIS_TRIM 0x40
478
479#ifdef notyet
480/*
481 * LZF hashtable/state size: on uncompressible data and on a system with
482 * a sufficiently large d-cache, a larger table produces a considerable
483 * speed benefit. On systems with small memory and caches, however...
484 */
485#if defined(__vax__) || defined(__m68k__)
486#define LZF_HLOG 14
487#else
488#define LZF_HLOG 15
489#endif
490typedef const uint8_t *LZF_STATE[1 << LZF_HLOG];
491
492unsigned int lzf_compress_r (const void *const, unsigned int, void *,
493 unsigned int, LZF_STATE);
494unsigned int lzf_decompress (const void *const, unsigned int, void *,
495 unsigned int);
496#endif
497
498#endif /* !_LIB_LIBKERN_LIBKERN_H_ */
499