/*      $NetBSD: libkern.h,v 1.148 2025/03/02 16:35:41 riastradh Exp $  */

/*-
* Copyright (c) 1992, 1993
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)libkern.h   8.2 (Berkeley) 8/5/94
*/

#ifndef _LIB_LIBKERN_LIBKERN_H_
#define _LIB_LIBKERN_LIBKERN_H_

#ifdef _KERNEL_OPT
#include "opt_kasan.h"
#include "opt_kcsan.h"
#include "opt_kmsan.h"
#endif

#include <sys/types.h>
#include <sys/inttypes.h>
#include <sys/null.h>
#include <sys/stddef.h>
#include <sys/container_of.h>

#include <lib/libkern/strlist.h>

#ifndef LIBKERN_INLINE
#define LIBKERN_INLINE  static __inline
#define LIBKERN_BODY
#endif

LIBKERN_INLINE int imax(int, int) __unused;
LIBKERN_INLINE int imin(int, int) __unused;
LIBKERN_INLINE u_int uimax(u_int, u_int) __unused;
LIBKERN_INLINE u_int uimin(u_int, u_int) __unused;
LIBKERN_INLINE long lmax(long, long) __unused;
LIBKERN_INLINE long lmin(long, long) __unused;
LIBKERN_INLINE u_long ulmax(u_long, u_long) __unused;
LIBKERN_INLINE u_long ulmin(u_long, u_long) __unused;
LIBKERN_INLINE int abs(int) __unused;
LIBKERN_INLINE long labs(long) __unused;
LIBKERN_INLINE long long llabs(long long) __unused;
LIBKERN_INLINE intmax_t imaxabs(intmax_t) __unused;

LIBKERN_INLINE int isspace(int) __unused;
LIBKERN_INLINE int isascii(int) __unused;
LIBKERN_INLINE int isupper(int) __unused;
LIBKERN_INLINE int islower(int) __unused;
LIBKERN_INLINE int isalpha(int) __unused;
LIBKERN_INLINE int isalnum(int) __unused;
LIBKERN_INLINE int isdigit(int) __unused;
LIBKERN_INLINE int isxdigit(int) __unused;
LIBKERN_INLINE int iscntrl(int) __unused;
LIBKERN_INLINE int isgraph(int) __unused;
LIBKERN_INLINE int isprint(int) __unused;
LIBKERN_INLINE int ispunct(int) __unused;
LIBKERN_INLINE int toupper(int) __unused;
LIBKERN_INLINE int tolower(int) __unused;

#ifdef LIBKERN_BODY
LIBKERN_INLINE int
imax(int a, int b)
{
       return (a > b ? a : b);
}
LIBKERN_INLINE int
imin(int a, int b)
{
       return (a < b ? a : b);
}
LIBKERN_INLINE long
lmax(long a, long b)
{
       return (a > b ? a : b);
}
LIBKERN_INLINE long
lmin(long a, long b)
{
       return (a < b ? a : b);
}
LIBKERN_INLINE u_int
uimax(u_int a, u_int b)
{
       return (a > b ? a : b);
}
LIBKERN_INLINE u_int
uimin(u_int a, u_int b)
{
       return (a < b ? a : b);
}
LIBKERN_INLINE u_long
ulmax(u_long a, u_long b)
{
       return (a > b ? a : b);
}
LIBKERN_INLINE u_long
ulmin(u_long a, u_long b)
{
       return (a < b ? a : b);
}

LIBKERN_INLINE int
abs(int j)
{
       return(j < 0 ? -j : j);
}

LIBKERN_INLINE long
labs(long j)
{
       return(j < 0 ? -j : j);
}

LIBKERN_INLINE long long
llabs(long long j)
{
       return(j < 0 ? -j : j);
}

LIBKERN_INLINE intmax_t
imaxabs(intmax_t j)
{
       return(j < 0 ? -j : j);
}

LIBKERN_INLINE int
isspace(int ch)
{
       return (ch == ' ' || (ch >= '\t' && ch <= '\r'));
}

LIBKERN_INLINE int
isascii(int ch)
{
       return ((ch & ~0x7f) == 0);
}

LIBKERN_INLINE int
isupper(int ch)
{
       return (ch >= 'A' && ch <= 'Z');
}

LIBKERN_INLINE int
islower(int ch)
{
       return (ch >= 'a' && ch <= 'z');
}

LIBKERN_INLINE int
isalpha(int ch)
{
       return (isupper(ch) || islower(ch));
}

LIBKERN_INLINE int
isalnum(int ch)
{
       return (isalpha(ch) || isdigit(ch));
}

LIBKERN_INLINE int
isdigit(int ch)
{
       return (ch >= '0' && ch <= '9');
}

LIBKERN_INLINE int
isxdigit(int ch)
{
       return (isdigit(ch) ||
           (ch >= 'A' && ch <= 'F') ||
           (ch >= 'a' && ch <= 'f'));
}

LIBKERN_INLINE int
iscntrl(int ch)
{
       return ((ch >= 0x00 && ch <= 0x1F) || ch == 0x7F);
}

LIBKERN_INLINE int
isgraph(int ch)
{
       return (ch != ' ' && isprint(ch));
}

LIBKERN_INLINE int
isprint(int ch)
{
       return (ch >= 0x20 && ch <= 0x7E);
}

LIBKERN_INLINE int
ispunct(int ch)
{
       return (isprint(ch) && ch != ' ' && !isalnum(ch));
}

LIBKERN_INLINE int
toupper(int ch)
{
       if (islower(ch))
               return (ch - 0x20);
       return (ch);
}

LIBKERN_INLINE int
tolower(int ch)
{
       if (isupper(ch))
               return (ch + 0x20);
       return (ch);
}
#endif

#define __NULL_STMT             do { } while (/* CONSTCOND */ 0)

#define __KASSERTSTR  "kernel %sassertion \"%s\" failed: file \"%s\", line %d "

#ifdef NDEBUG                                           /* tradition! */
#define assert(e)       ((void)0)
#else
#define assert(e)       (__predict_true((e)) ? (void)0 :                    \
                           kern_assert(__KASSERTSTR, "", #e, __FILE__, __LINE__))
#endif

#ifdef __COVERITY__
#ifndef DIAGNOSTIC
#define DIAGNOSTIC
#endif
#endif

#ifndef CTASSERT
#define CTASSERT(x)             __CTASSERT(x)
#endif
#ifndef CTASSERT_SIGNED
#define CTASSERT_SIGNED(x)      __CTASSERT(((typeof(x))-1) < 0)
#endif
#ifndef CTASSERT_UNSIGNED
#define CTASSERT_UNSIGNED(x)    __CTASSERT(((typeof(x))-1) >= 0)
#endif

#ifndef DIAGNOSTIC
#define _DIAGASSERT(a)  (void)0
#ifdef lint
#define KASSERTMSG(e, msg, ...) /* NOTHING */
#define KASSERT(e)              /* NOTHING */
#else /* !lint */
/*
* Make sure the expression compiles, but don't evaluate any of it.  We
* use sizeof to inhibit evaluation, and cast to long so the expression
* can be integer- or pointer-valued without bringing in other header
* files.
*/
#define KASSERTMSG(e, msg, ...) ((void)sizeof((long)(e)))
#define KASSERT(e)              ((void)sizeof((long)(e)))
#endif /* !lint */
#else /* DIAGNOSTIC */
#define _DIAGASSERT(a)  assert(a)
#define KASSERTMSG(e, msg, ...)         \
                       (__predict_true((e)) ? (void)0 :                    \
                           kern_assert(__KASSERTSTR msg, "diagnostic ", #e,        \
                               __FILE__, __LINE__, ## __VA_ARGS__))

#define KASSERT(e)      (__predict_true((e)) ? (void)0 :                    \
                           kern_assert(__KASSERTSTR, "diagnostic ", #e,            \
                               __FILE__, __LINE__))
#endif

#ifndef DEBUG
#ifdef lint
#define KDASSERTMSG(e,msg, ...) /* NOTHING */
#define KDASSERT(e)             /* NOTHING */
#else /* lint */
#define KDASSERTMSG(e,msg, ...) ((void)0)
#define KDASSERT(e)             ((void)0)
#endif /* lint */
#else
#define KDASSERTMSG(e, msg, ...)        \
                       (__predict_true((e)) ? (void)0 :                    \
                           kern_assert(__KASSERTSTR msg, "debugging ", #e,         \
                               __FILE__, __LINE__, ## __VA_ARGS__))

#define KDASSERT(e)     (__predict_true((e)) ? (void)0 :                    \
                           kern_assert(__KASSERTSTR, "debugging ", #e,     \
                               __FILE__, __LINE__))
#endif

/*
* XXX: For compatibility we use SMALL_RANDOM by default.
*/
#define SMALL_RANDOM

/* Prototypes for which GCC built-ins exist. */
void    *memcpy(void *, const void *, size_t);
int      memcmp(const void *, const void *, size_t);
void    *memset(void *, int, size_t);
#if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
#if defined(_KERNEL) && defined(KASAN)
void    *kasan_memcpy(void *, const void *, size_t);
int      kasan_memcmp(const void *, const void *, size_t);
void    *kasan_memset(void *, int, size_t);
#define memcpy(d, s, l)         kasan_memcpy(d, s, l)
#define memcmp(a, b, l)         kasan_memcmp(a, b, l)
#define memset(d, v, l)         kasan_memset(d, v, l)
#elif defined(_KERNEL) && defined(KCSAN)
void    *kcsan_memcpy(void *, const void *, size_t);
int      kcsan_memcmp(const void *, const void *, size_t);
void    *kcsan_memset(void *, int, size_t);
#define memcpy(d, s, l)         kcsan_memcpy(d, s, l)
#define memcmp(a, b, l)         kcsan_memcmp(a, b, l)
#define memset(d, v, l)         kcsan_memset(d, v, l)
#elif defined(_KERNEL) && defined(KMSAN)
void    *kmsan_memcpy(void *, const void *, size_t);
int      kmsan_memcmp(const void *, const void *, size_t);
void    *kmsan_memset(void *, int, size_t);
#define memcpy(d, s, l)         kmsan_memcpy(d, s, l)
#define memcmp(a, b, l)         kmsan_memcmp(a, b, l)
#define memset(d, v, l)         kmsan_memset(d, v, l)
#else
#define memcpy(d, s, l)         __builtin_memcpy(d, s, l)
#define memcmp(a, b, l)         __builtin_memcmp(a, b, l)
#define memset(d, v, l)         __builtin_memset(d, v, l)
#endif
#endif
void    *memmem(const void *, size_t, const void *, size_t);

char    *strcpy(char *, const char *);
int      strcmp(const char *, const char *);
size_t   strlen(const char *);
#if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
#if defined(_KERNEL) && defined(KASAN)
char    *kasan_strcpy(char *, const char *);
int      kasan_strcmp(const char *, const char *);
size_t   kasan_strlen(const char *);
#define strcpy(d, s)            kasan_strcpy(d, s)
#define strcmp(a, b)            kasan_strcmp(a, b)
#define strlen(a)               kasan_strlen(a)
#elif defined(_KERNEL) && defined(KCSAN)
char    *kcsan_strcpy(char *, const char *);
int      kcsan_strcmp(const char *, const char *);
size_t   kcsan_strlen(const char *);
#define strcpy(d, s)            kcsan_strcpy(d, s)
#define strcmp(a, b)            kcsan_strcmp(a, b)
#define strlen(a)               kcsan_strlen(a)
#elif defined(_KERNEL) && defined(KMSAN)
char    *kmsan_strcpy(char *, const char *);
int      kmsan_strcmp(const char *, const char *);
size_t   kmsan_strlen(const char *);
#define strcpy(d, s)            kmsan_strcpy(d, s)
#define strcmp(a, b)            kmsan_strcmp(a, b)
#define strlen(a)               kmsan_strlen(a)
#else
#define strcpy(d, s)            __builtin_strcpy(d, s)
#define strcmp(a, b)            __builtin_strcmp(a, b)
#define strlen(a)               __builtin_strlen(a)
#endif
#endif
size_t   strnlen(const char *, size_t);
char    *strsep(char **, const char *);

/* Functions for which we always use built-ins. */
#ifdef __GNUC__
#define alloca(s)               __builtin_alloca(s)
#endif

/* These exist in GCC 3.x, but we don't bother. */
char    *strcat(char *, const char *);
char    *strchr(const char *, int);
char    *strrchr(const char *, int);
#if defined(_KERNEL) && defined(KASAN)
char    *kasan_strcat(char *, const char *);
char    *kasan_strchr(const char *, int);
char    *kasan_strrchr(const char *, int);
#define strcat(d, s)            kasan_strcat(d, s)
#define strchr(s, c)            kasan_strchr(s, c)
#define strrchr(s, c)           kasan_strrchr(s, c)
#elif defined(_KERNEL) && defined(KMSAN)
char    *kmsan_strcat(char *, const char *);
char    *kmsan_strchr(const char *, int);
char    *kmsan_strrchr(const char *, int);
#define strcat(d, s)            kmsan_strcat(d, s)
#define strchr(s, c)            kmsan_strchr(s, c)
#define strrchr(s, c)           kmsan_strrchr(s, c)
#endif
size_t   strcspn(const char *, const char *);
char    *strncpy(char *, const char *, size_t);
char    *strncat(char *, const char *, size_t);
int      strncmp(const char *, const char *, size_t);
char    *strstr(const char *, const char *);
char    *strpbrk(const char *, const char *);
size_t   strspn(const char *, const char *);

/*
* ffs is an instruction on vax.
*/
int      ffs(int);
#if __GNUC_PREREQ__(2, 95) && (!defined(__vax__) || __GNUC_PREREQ__(4,1))
#define ffs(x)          __builtin_ffs(x)
#endif

void     kern_assert(const char *, ...)
   __attribute__((__format__(__printf__, 1, 2)));
u_int32_t
       inet_addr(const char *);
struct in_addr;
int     inet_aton(const char *, struct in_addr *);
char    *intoa(u_int32_t);
#define inet_ntoa(a) intoa((a).s_addr)
void    *memchr(const void *, int, size_t);

void    *memmove(void *, const void *, size_t);
#if defined(_KERNEL) && defined(KASAN)
void    *kasan_memmove(void *, const void *, size_t);
#define memmove(d, s, l)        kasan_memmove(d, s, l)
#elif defined(_KERNEL) && defined(KCSAN)
void    *kcsan_memmove(void *, const void *, size_t);
#define memmove(d, s, l)        kcsan_memmove(d, s, l)
#elif defined(_KERNEL) && defined(KMSAN)
void    *kmsan_memmove(void *, const void *, size_t);
#define memmove(d, s, l)        kmsan_memmove(d, s, l)
#endif

int      pmatch(const char *, const char *, const char **);
#ifndef SMALL_RANDOM
void     srandom(unsigned long);
char    *initstate(unsigned long, char *, size_t);
char    *setstate(char *);
#endif /* SMALL_RANDOM */
long     random(void);
void     mi_vector_hash(const void * __restrict, size_t, uint32_t,
           uint32_t[3]);
int      scanc(u_int, const u_char *, const u_char *, int);
int      skpc(int, size_t, u_char *);
int      strcasecmp(const char *, const char *);
size_t   strlcpy(char * __restrict, const char * __restrict, size_t);
size_t   strlcat(char * __restrict, const char * __restrict, size_t);
int      strncasecmp(const char *, const char *, size_t);
u_long   strtoul(const char *, char **, int);
long long strtoll(const char *, char **, int);
unsigned long long strtoull(const char *, char **, int);
intmax_t  strtoimax(const char *, char **, int);
uintmax_t strtoumax(const char *, char **, int);
intmax_t strtoi(const char * __restrict, char ** __restrict, int, intmax_t,
   intmax_t, int *);
uintmax_t strtou(const char * __restrict, char ** __restrict, int, uintmax_t,
   uintmax_t, int *);
void     hexdump(void (*)(const char *, ...) __printflike(1, 2),
   const char *, const void *, size_t);

int      snprintb(char *, size_t, const char *, uint64_t);
int      snprintb_m(char *, size_t, const char *, uint64_t, size_t);
int      kheapsort(void *, size_t, size_t, int (*)(const void *, const void *),
           void *);
int      kheapsort_r(void *, size_t, size_t,
           int (*)(const void *, const void *, void *), void *,
           void *);
uint32_t crc32(uint32_t, const uint8_t *, size_t);
#if __GNUC_PREREQ__(4, 5) \
   && (defined(__alpha_cix__) || defined(__mips_popcount))
#define popcount        __builtin_popcount
#define popcountl       __builtin_popcountl
#define popcountll      __builtin_popcountll
#define popcount32      __builtin_popcount
#define popcount64      __builtin_popcountll
#else
unsigned int    popcount(unsigned int) __constfunc;
unsigned int    popcountl(unsigned long) __constfunc;
unsigned int    popcountll(unsigned long long) __constfunc;
unsigned int    popcount32(uint32_t) __constfunc;
unsigned int    popcount64(uint64_t) __constfunc;
#endif

void    *explicit_memset(void *, int, size_t);
int     consttime_memequal(const void *, const void *, size_t);
int     strnvisx(char *, size_t, const char *, size_t, int);
#define VIS_OCTAL       0x01
#define VIS_SAFE        0x20
#define VIS_TRIM        0x40

struct disklabel;
void    disklabel_swap(struct disklabel *, struct disklabel *);
uint16_t dkcksum(const struct disklabel *);
uint16_t dkcksum_sized(const struct disklabel *, size_t);

#endif /* !_LIB_LIBKERN_LIBKERN_H_ */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.