18d59ecb2SHans Petter Selasky /*- 28d59ecb2SHans Petter Selasky * Copyright (c) 2010 Isilon Systems, Inc. 38d59ecb2SHans Petter Selasky * Copyright (c) 2010 iX Systems, Inc. 48d59ecb2SHans Petter Selasky * Copyright (c) 2010 Panasas, Inc. 5fe68f570SHans Petter Selasky * Copyright (c) 2013-2016 Mellanox Technologies, Ltd. 68d59ecb2SHans Petter Selasky * Copyright (c) 2014-2015 François Tigeot 78d59ecb2SHans Petter Selasky * All rights reserved. 88d59ecb2SHans Petter Selasky * 98d59ecb2SHans Petter Selasky * Redistribution and use in source and binary forms, with or without 108d59ecb2SHans Petter Selasky * modification, are permitted provided that the following conditions 118d59ecb2SHans Petter Selasky * are met: 128d59ecb2SHans Petter Selasky * 1. Redistributions of source code must retain the above copyright 138d59ecb2SHans Petter Selasky * notice unmodified, this list of conditions, and the following 148d59ecb2SHans Petter Selasky * disclaimer. 158d59ecb2SHans Petter Selasky * 2. Redistributions in binary form must reproduce the above copyright 168d59ecb2SHans Petter Selasky * notice, this list of conditions and the following disclaimer in the 178d59ecb2SHans Petter Selasky * documentation and/or other materials provided with the distribution. 188d59ecb2SHans Petter Selasky * 198d59ecb2SHans Petter Selasky * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 208d59ecb2SHans Petter Selasky * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 218d59ecb2SHans Petter Selasky * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 228d59ecb2SHans Petter Selasky * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 238d59ecb2SHans Petter Selasky * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 248d59ecb2SHans Petter Selasky * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 258d59ecb2SHans Petter Selasky * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 268d59ecb2SHans Petter Selasky * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 278d59ecb2SHans Petter Selasky * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 288d59ecb2SHans Petter Selasky * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 298d59ecb2SHans Petter Selasky * 308d59ecb2SHans Petter Selasky * $FreeBSD$ 318d59ecb2SHans Petter Selasky */ 32307f78f3SVladimir Kondratyev #ifndef _LINUXKPI_LINUX_KERNEL_H_ 33307f78f3SVladimir Kondratyev #define _LINUXKPI_LINUX_KERNEL_H_ 348d59ecb2SHans Petter Selasky 358d59ecb2SHans Petter Selasky #include <sys/cdefs.h> 368d59ecb2SHans Petter Selasky #include <sys/types.h> 378d59ecb2SHans Petter Selasky #include <sys/systm.h> 388d59ecb2SHans Petter Selasky #include <sys/param.h> 398d59ecb2SHans Petter Selasky #include <sys/libkern.h> 408d59ecb2SHans Petter Selasky #include <sys/stat.h> 418d59ecb2SHans Petter Selasky #include <sys/smp.h> 428d59ecb2SHans Petter Selasky #include <sys/stddef.h> 438d59ecb2SHans Petter Selasky #include <sys/syslog.h> 448f7eee5aSHans Petter Selasky #include <sys/time.h> 458d59ecb2SHans Petter Selasky 468d59ecb2SHans Petter Selasky #include <linux/bitops.h> 478d59ecb2SHans Petter Selasky #include <linux/compiler.h> 4843b4c006SBjoern A. Zeeb #include <linux/stringify.h> 498d59ecb2SHans Petter Selasky #include <linux/errno.h> 501e3db1deSHans Petter Selasky #include <linux/sched.h> 518d59ecb2SHans Petter Selasky #include <linux/types.h> 524b2cb13eSEmmanuel Vadot #include <linux/typecheck.h> 538d59ecb2SHans Petter Selasky #include <linux/jiffies.h> 548d59ecb2SHans Petter Selasky #include <linux/log2.h> 554b0552d5SJean-Sébastien Pédron #include <linux/kconfig.h> 5635555d47SHans Petter Selasky 578d59ecb2SHans Petter Selasky #include <asm/byteorder.h> 584b2cb13eSEmmanuel Vadot #include <asm/cpufeature.h> 594b2cb13eSEmmanuel Vadot #include <asm/processor.h> 6035555d47SHans Petter Selasky #include <asm/uaccess.h> 618d59ecb2SHans Petter Selasky 62d91cf060SJean-Sébastien Pédron #include <linux/stdarg.h> 63aef2a67bSHans Petter Selasky 648d59ecb2SHans Petter Selasky #define KERN_CONT "" 658d59ecb2SHans Petter Selasky #define KERN_EMERG "<0>" 668d59ecb2SHans Petter Selasky #define KERN_ALERT "<1>" 678d59ecb2SHans Petter Selasky #define KERN_CRIT "<2>" 688d59ecb2SHans Petter Selasky #define KERN_ERR "<3>" 698d59ecb2SHans Petter Selasky #define KERN_WARNING "<4>" 708d59ecb2SHans Petter Selasky #define KERN_NOTICE "<5>" 718d59ecb2SHans Petter Selasky #define KERN_INFO "<6>" 728d59ecb2SHans Petter Selasky #define KERN_DEBUG "<7>" 738d59ecb2SHans Petter Selasky 74abb14a54SHans Petter Selasky #define U8_MAX ((u8)~0U) 75abb14a54SHans Petter Selasky #define S8_MAX ((s8)(U8_MAX >> 1)) 76abb14a54SHans Petter Selasky #define S8_MIN ((s8)(-S8_MAX - 1)) 77abb14a54SHans Petter Selasky #define U16_MAX ((u16)~0U) 78abb14a54SHans Petter Selasky #define S16_MAX ((s16)(U16_MAX >> 1)) 79abb14a54SHans Petter Selasky #define S16_MIN ((s16)(-S16_MAX - 1)) 80abb14a54SHans Petter Selasky #define U32_MAX ((u32)~0U) 81abb14a54SHans Petter Selasky #define S32_MAX ((s32)(U32_MAX >> 1)) 82abb14a54SHans Petter Selasky #define S32_MIN ((s32)(-S32_MAX - 1)) 83abb14a54SHans Petter Selasky #define U64_MAX ((u64)~0ULL) 84abb14a54SHans Petter Selasky #define S64_MAX ((s64)(U64_MAX >> 1)) 85abb14a54SHans Petter Selasky #define S64_MIN ((s64)(-S64_MAX - 1)) 86abb14a54SHans Petter Selasky 87abb14a54SHans Petter Selasky #define S8_C(x) x 88abb14a54SHans Petter Selasky #define U8_C(x) x ## U 89abb14a54SHans Petter Selasky #define S16_C(x) x 90abb14a54SHans Petter Selasky #define U16_C(x) x ## U 91abb14a54SHans Petter Selasky #define S32_C(x) x 92abb14a54SHans Petter Selasky #define U32_C(x) x ## U 93abb14a54SHans Petter Selasky #define S64_C(x) x ## LL 94abb14a54SHans Petter Selasky #define U64_C(x) x ## ULL 95abb14a54SHans Petter Selasky 961082490cSBjoern A. Zeeb /* 971082490cSBjoern A. Zeeb * BUILD_BUG_ON() can happen inside functions where _Static_assert() does not 981082490cSBjoern A. Zeeb * seem to work. Use old-schoold-ish CTASSERT from before commit 991082490cSBjoern A. Zeeb * a3085588a88fa58eb5b1eaae471999e1995a29cf but also make sure we do not 1001082490cSBjoern A. Zeeb * end up with an unused typedef or variable. The compiler should optimise 1011082490cSBjoern A. Zeeb * it away entirely. 1021082490cSBjoern A. Zeeb */ 1031082490cSBjoern A. Zeeb #define _O_CTASSERT(x) _O__CTASSERT(x, __LINE__) 1041082490cSBjoern A. Zeeb #define _O__CTASSERT(x, y) _O___CTASSERT(x, y) 1051082490cSBjoern A. Zeeb #define _O___CTASSERT(x, y) while (0) { \ 1061082490cSBjoern A. Zeeb typedef char __assert_line_ ## y[(x) ? 1 : -1]; \ 1071082490cSBjoern A. Zeeb __assert_line_ ## y _x; \ 1081082490cSBjoern A. Zeeb _x[0] = '\0'; \ 1091082490cSBjoern A. Zeeb } 1101082490cSBjoern A. Zeeb 111e9e4ec11SHans Petter Selasky #define BUILD_BUG() do { CTASSERT(0); } while (0) 1126d15ccdeSAlex Richardson #define BUILD_BUG_ON(x) do { _O_CTASSERT(!(x)) } while (0) 113cb564d24SMark Johnston #define BUILD_BUG_ON_MSG(x, msg) BUILD_BUG_ON(x) 114cb564d24SMark Johnston #define BUILD_BUG_ON_NOT_POWER_OF_2(x) BUILD_BUG_ON(!powerof2(x)) 1152460cbb4SHans Petter Selasky #define BUILD_BUG_ON_INVALID(expr) while (0) { (void)(expr); } 11664dab63fSVladimir Kondratyev #define BUILD_BUG_ON_ZERO(x) ((int)sizeof(struct { int:-((x) != 0); })) 117c185f13bSHans Petter Selasky 118abb14a54SHans Petter Selasky #define BUG() panic("BUG at %s:%d", __FILE__, __LINE__) 119abb14a54SHans Petter Selasky #define BUG_ON(cond) do { \ 120abb14a54SHans Petter Selasky if (cond) { \ 121abb14a54SHans Petter Selasky panic("BUG ON %s failed at %s:%d", \ 122abb14a54SHans Petter Selasky __stringify(cond), __FILE__, __LINE__); \ 123abb14a54SHans Petter Selasky } \ 124abb14a54SHans Petter Selasky } while (0) 125abb14a54SHans Petter Selasky 1262390a144SHans Petter Selasky extern int linuxkpi_warn_dump_stack; 127abb14a54SHans Petter Selasky #define WARN_ON(cond) ({ \ 128abb14a54SHans Petter Selasky bool __ret = (cond); \ 129abb14a54SHans Petter Selasky if (__ret) { \ 130abb14a54SHans Petter Selasky printf("WARNING %s failed at %s:%d\n", \ 131abb14a54SHans Petter Selasky __stringify(cond), __FILE__, __LINE__); \ 1322390a144SHans Petter Selasky if (linuxkpi_warn_dump_stack) \ 133a164a32bSAndriy Gapon linux_dump_stack(); \ 134abb14a54SHans Petter Selasky } \ 135abb14a54SHans Petter Selasky unlikely(__ret); \ 136abb14a54SHans Petter Selasky }) 137abb14a54SHans Petter Selasky 138abb14a54SHans Petter Selasky #define WARN_ON_SMP(cond) WARN_ON(cond) 139abb14a54SHans Petter Selasky 140abb14a54SHans Petter Selasky #define WARN_ON_ONCE(cond) ({ \ 141abb14a54SHans Petter Selasky static bool __warn_on_once; \ 142abb14a54SHans Petter Selasky bool __ret = (cond); \ 143abb14a54SHans Petter Selasky if (__ret && !__warn_on_once) { \ 144abb14a54SHans Petter Selasky __warn_on_once = 1; \ 145abb14a54SHans Petter Selasky printf("WARNING %s failed at %s:%d\n", \ 146abb14a54SHans Petter Selasky __stringify(cond), __FILE__, __LINE__); \ 1472390a144SHans Petter Selasky if (linuxkpi_warn_dump_stack) \ 148a164a32bSAndriy Gapon linux_dump_stack(); \ 149abb14a54SHans Petter Selasky } \ 150abb14a54SHans Petter Selasky unlikely(__ret); \ 151abb14a54SHans Petter Selasky }) 1528d59ecb2SHans Petter Selasky 153cb564d24SMark Johnston #define oops_in_progress SCHEDULER_STOPPED() 154cb564d24SMark Johnston 1558d59ecb2SHans Petter Selasky #undef ALIGN 1568d59ecb2SHans Petter Selasky #define ALIGN(x, y) roundup2((x), (y)) 15797f2e93aSBjoern A. Zeeb #define ALIGN_DOWN(x, y) rounddown2(x, y) 1588d59ecb2SHans Petter Selasky #undef PTR_ALIGN 1598d59ecb2SHans Petter Selasky #define PTR_ALIGN(p, a) ((__typeof(p))ALIGN((uintptr_t)(p), (a))) 160c4e0746eSJohannes Lundberg #define IS_ALIGNED(x, a) (((x) & ((__typeof(x))(a) - 1)) == 0) 1618d59ecb2SHans Petter Selasky #define DIV_ROUND_UP(x, n) howmany(x, n) 162bf05cd05SHans Petter Selasky #define __KERNEL_DIV_ROUND_UP(x, n) howmany(x, n) 1638d59ecb2SHans Petter Selasky #define DIV_ROUND_UP_ULL(x, n) DIV_ROUND_UP((unsigned long long)(x), (n)) 164c4e0746eSJohannes Lundberg #define DIV_ROUND_DOWN_ULL(x, n) (((unsigned long long)(x) / (n)) * (n)) 1658d59ecb2SHans Petter Selasky #define FIELD_SIZEOF(t, f) sizeof(((t *)0)->f) 1668d59ecb2SHans Petter Selasky 167aef2a67bSHans Petter Selasky #define printk(...) printf(__VA_ARGS__) 168aef2a67bSHans Petter Selasky #define vprintk(f, a) vprintf(f, a) 169aef2a67bSHans Petter Selasky 1700df8bab6SHans Petter Selasky #define asm __asm 1710df8bab6SHans Petter Selasky 172e35079dbSHans Petter Selasky extern void linux_dump_stack(void); 173e35079dbSHans Petter Selasky #define dump_stack() linux_dump_stack() 174e35079dbSHans Petter Selasky 175aef2a67bSHans Petter Selasky struct va_format { 176aef2a67bSHans Petter Selasky const char *fmt; 177aef2a67bSHans Petter Selasky va_list *va; 178aef2a67bSHans Petter Selasky }; 179aef2a67bSHans Petter Selasky 180aef2a67bSHans Petter Selasky static inline int 181aef2a67bSHans Petter Selasky vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 182aef2a67bSHans Petter Selasky { 183aef2a67bSHans Petter Selasky ssize_t ssize = size; 184aef2a67bSHans Petter Selasky int i; 185aef2a67bSHans Petter Selasky 186aef2a67bSHans Petter Selasky i = vsnprintf(buf, size, fmt, args); 187aef2a67bSHans Petter Selasky 188aef2a67bSHans Petter Selasky return ((i >= ssize) ? (ssize - 1) : i); 189aef2a67bSHans Petter Selasky } 190aef2a67bSHans Petter Selasky 191aef2a67bSHans Petter Selasky static inline int 192aef2a67bSHans Petter Selasky scnprintf(char *buf, size_t size, const char *fmt, ...) 193aef2a67bSHans Petter Selasky { 194aef2a67bSHans Petter Selasky va_list args; 195aef2a67bSHans Petter Selasky int i; 196aef2a67bSHans Petter Selasky 197aef2a67bSHans Petter Selasky va_start(args, fmt); 198aef2a67bSHans Petter Selasky i = vscnprintf(buf, size, fmt, args); 199aef2a67bSHans Petter Selasky va_end(args); 200aef2a67bSHans Petter Selasky 201aef2a67bSHans Petter Selasky return (i); 202aef2a67bSHans Petter Selasky } 2038d59ecb2SHans Petter Selasky 2048d59ecb2SHans Petter Selasky /* 2058d59ecb2SHans Petter Selasky * The "pr_debug()" and "pr_devel()" macros should produce zero code 2068d59ecb2SHans Petter Selasky * unless DEBUG is defined: 2078d59ecb2SHans Petter Selasky */ 2088d59ecb2SHans Petter Selasky #ifdef DEBUG 2094580f5eaSHans Petter Selasky extern int linuxkpi_debug; 2108d59ecb2SHans Petter Selasky #define pr_debug(fmt, ...) \ 2114580f5eaSHans Petter Selasky do { \ 2124580f5eaSHans Petter Selasky if (linuxkpi_debug) \ 2134580f5eaSHans Petter Selasky log(LOG_DEBUG, fmt, ##__VA_ARGS__); \ 2144580f5eaSHans Petter Selasky } while (0) 2158d59ecb2SHans Petter Selasky #define pr_devel(fmt, ...) \ 2168d59ecb2SHans Petter Selasky log(LOG_DEBUG, pr_fmt(fmt), ##__VA_ARGS__) 2178d59ecb2SHans Petter Selasky #else 2188d59ecb2SHans Petter Selasky #define pr_debug(fmt, ...) \ 2198d59ecb2SHans Petter Selasky ({ if (0) log(LOG_DEBUG, fmt, ##__VA_ARGS__); 0; }) 2208d59ecb2SHans Petter Selasky #define pr_devel(fmt, ...) \ 2218d59ecb2SHans Petter Selasky ({ if (0) log(LOG_DEBUG, pr_fmt(fmt), ##__VA_ARGS__); 0; }) 2228d59ecb2SHans Petter Selasky #endif 2238d59ecb2SHans Petter Selasky 2248d59ecb2SHans Petter Selasky #ifndef pr_fmt 2258d59ecb2SHans Petter Selasky #define pr_fmt(fmt) fmt 2268d59ecb2SHans Petter Selasky #endif 2278d59ecb2SHans Petter Selasky 2288d59ecb2SHans Petter Selasky /* 2298d59ecb2SHans Petter Selasky * Print a one-time message (analogous to WARN_ONCE() et al): 2308d59ecb2SHans Petter Selasky */ 2318d59ecb2SHans Petter Selasky #define printk_once(...) do { \ 2328d59ecb2SHans Petter Selasky static bool __print_once; \ 2338d59ecb2SHans Petter Selasky \ 2348d59ecb2SHans Petter Selasky if (!__print_once) { \ 2358d59ecb2SHans Petter Selasky __print_once = true; \ 2368d59ecb2SHans Petter Selasky printk(__VA_ARGS__); \ 2378d59ecb2SHans Petter Selasky } \ 2388d59ecb2SHans Petter Selasky } while (0) 2398d59ecb2SHans Petter Selasky 2408d59ecb2SHans Petter Selasky /* 2418d59ecb2SHans Petter Selasky * Log a one-time message (analogous to WARN_ONCE() et al): 2428d59ecb2SHans Petter Selasky */ 2438d59ecb2SHans Petter Selasky #define log_once(level,...) do { \ 2448d59ecb2SHans Petter Selasky static bool __log_once; \ 2458d59ecb2SHans Petter Selasky \ 246abb14a54SHans Petter Selasky if (unlikely(!__log_once)) { \ 2478d59ecb2SHans Petter Selasky __log_once = true; \ 2488d59ecb2SHans Petter Selasky log(level, __VA_ARGS__); \ 2498d59ecb2SHans Petter Selasky } \ 2508d59ecb2SHans Petter Selasky } while (0) 2518d59ecb2SHans Petter Selasky 2528d59ecb2SHans Petter Selasky #define pr_emerg(fmt, ...) \ 2538d59ecb2SHans Petter Selasky log(LOG_EMERG, pr_fmt(fmt), ##__VA_ARGS__) 2548d59ecb2SHans Petter Selasky #define pr_alert(fmt, ...) \ 2558d59ecb2SHans Petter Selasky log(LOG_ALERT, pr_fmt(fmt), ##__VA_ARGS__) 2568d59ecb2SHans Petter Selasky #define pr_crit(fmt, ...) \ 2578d59ecb2SHans Petter Selasky log(LOG_CRIT, pr_fmt(fmt), ##__VA_ARGS__) 2588d59ecb2SHans Petter Selasky #define pr_err(fmt, ...) \ 2598d59ecb2SHans Petter Selasky log(LOG_ERR, pr_fmt(fmt), ##__VA_ARGS__) 26005c2d94aSGreg V #define pr_err_once(fmt, ...) \ 26105c2d94aSGreg V log_once(LOG_ERR, pr_fmt(fmt), ##__VA_ARGS__) 2628d59ecb2SHans Petter Selasky #define pr_warning(fmt, ...) \ 2638d59ecb2SHans Petter Selasky log(LOG_WARNING, pr_fmt(fmt), ##__VA_ARGS__) 264abb14a54SHans Petter Selasky #define pr_warn(...) \ 265abb14a54SHans Petter Selasky pr_warning(__VA_ARGS__) 266abb14a54SHans Petter Selasky #define pr_warn_once(fmt, ...) \ 267abb14a54SHans Petter Selasky log_once(LOG_WARNING, pr_fmt(fmt), ##__VA_ARGS__) 2688d59ecb2SHans Petter Selasky #define pr_notice(fmt, ...) \ 2698d59ecb2SHans Petter Selasky log(LOG_NOTICE, pr_fmt(fmt), ##__VA_ARGS__) 2708d59ecb2SHans Petter Selasky #define pr_info(fmt, ...) \ 2718d59ecb2SHans Petter Selasky log(LOG_INFO, pr_fmt(fmt), ##__VA_ARGS__) 2728d59ecb2SHans Petter Selasky #define pr_info_once(fmt, ...) \ 2738d59ecb2SHans Petter Selasky log_once(LOG_INFO, pr_fmt(fmt), ##__VA_ARGS__) 2748d59ecb2SHans Petter Selasky #define pr_cont(fmt, ...) \ 2758d59ecb2SHans Petter Selasky printk(KERN_CONT fmt, ##__VA_ARGS__) 276e9db3df2SHans Petter Selasky #define pr_warn_ratelimited(...) do { \ 2778f7eee5aSHans Petter Selasky static linux_ratelimit_t __ratelimited; \ 278e9db3df2SHans Petter Selasky if (linux_ratelimited(&__ratelimited)) \ 279e9db3df2SHans Petter Selasky pr_warning(__VA_ARGS__); \ 280e9db3df2SHans Petter Selasky } while (0) 2818d59ecb2SHans Petter Selasky 2828d59ecb2SHans Petter Selasky #ifndef WARN 283abb14a54SHans Petter Selasky #define WARN(condition, ...) ({ \ 284abb14a54SHans Petter Selasky bool __ret_warn_on = (condition); \ 2858d59ecb2SHans Petter Selasky if (unlikely(__ret_warn_on)) \ 286abb14a54SHans Petter Selasky pr_warning(__VA_ARGS__); \ 287abb14a54SHans Petter Selasky unlikely(__ret_warn_on); \ 288abb14a54SHans Petter Selasky }) 289abb14a54SHans Petter Selasky #endif 290abb14a54SHans Petter Selasky 291abb14a54SHans Petter Selasky #ifndef WARN_ONCE 292abb14a54SHans Petter Selasky #define WARN_ONCE(condition, ...) ({ \ 293abb14a54SHans Petter Selasky bool __ret_warn_on = (condition); \ 294abb14a54SHans Petter Selasky if (unlikely(__ret_warn_on)) \ 295abb14a54SHans Petter Selasky pr_warn_once(__VA_ARGS__); \ 2968d59ecb2SHans Petter Selasky unlikely(__ret_warn_on); \ 2978d59ecb2SHans Petter Selasky }) 2988d59ecb2SHans Petter Selasky #endif 2998d59ecb2SHans Petter Selasky 3008d59ecb2SHans Petter Selasky #define container_of(ptr, type, member) \ 3018d59ecb2SHans Petter Selasky ({ \ 302ddad2785SHans Petter Selasky const __typeof(((type *)0)->member) *__p = (ptr); \ 303ddad2785SHans Petter Selasky (type *)((uintptr_t)__p - offsetof(type, member)); \ 3048d59ecb2SHans Petter Selasky }) 3058d59ecb2SHans Petter Selasky 3068d59ecb2SHans Petter Selasky #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 3078d59ecb2SHans Petter Selasky 308ee7c3198SMark Johnston #define u64_to_user_ptr(val) ((void *)(uintptr_t)(val)) 309ee7c3198SMark Johnston 310fee0d486SNeel Chauhan #define _RET_IP_ __builtin_return_address(0) 311fee0d486SNeel Chauhan 312d2f312e0SHans Petter Selasky static inline unsigned long long 313d2f312e0SHans Petter Selasky simple_strtoull(const char *cp, char **endp, unsigned int base) 314d2f312e0SHans Petter Selasky { 315d2f312e0SHans Petter Selasky return (strtouq(cp, endp, base)); 316d2f312e0SHans Petter Selasky } 317d2f312e0SHans Petter Selasky 318d2f312e0SHans Petter Selasky static inline long long 319d2f312e0SHans Petter Selasky simple_strtoll(const char *cp, char **endp, unsigned int base) 320d2f312e0SHans Petter Selasky { 321d2f312e0SHans Petter Selasky return (strtoq(cp, endp, base)); 322d2f312e0SHans Petter Selasky } 323d2f312e0SHans Petter Selasky 324d2f312e0SHans Petter Selasky static inline unsigned long 325d2f312e0SHans Petter Selasky simple_strtoul(const char *cp, char **endp, unsigned int base) 326d2f312e0SHans Petter Selasky { 327d2f312e0SHans Petter Selasky return (strtoul(cp, endp, base)); 328d2f312e0SHans Petter Selasky } 329d2f312e0SHans Petter Selasky 330d2f312e0SHans Petter Selasky static inline long 331d2f312e0SHans Petter Selasky simple_strtol(const char *cp, char **endp, unsigned int base) 332d2f312e0SHans Petter Selasky { 333d2f312e0SHans Petter Selasky return (strtol(cp, endp, base)); 334d2f312e0SHans Petter Selasky } 335d2f312e0SHans Petter Selasky 336d2f312e0SHans Petter Selasky static inline int 337d2f312e0SHans Petter Selasky kstrtoul(const char *cp, unsigned int base, unsigned long *res) 338d2f312e0SHans Petter Selasky { 339d2f312e0SHans Petter Selasky char *end; 340d2f312e0SHans Petter Selasky 341d2f312e0SHans Petter Selasky *res = strtoul(cp, &end, base); 342d2f312e0SHans Petter Selasky 343cbfc3c73SHans Petter Selasky /* skip newline character, if any */ 344cbfc3c73SHans Petter Selasky if (*end == '\n') 345cbfc3c73SHans Petter Selasky end++; 346d2f312e0SHans Petter Selasky if (*cp == 0 || *end != 0) 347d2f312e0SHans Petter Selasky return (-EINVAL); 348d2f312e0SHans Petter Selasky return (0); 349d2f312e0SHans Petter Selasky } 350d2f312e0SHans Petter Selasky 351d2f312e0SHans Petter Selasky static inline int 352d2f312e0SHans Petter Selasky kstrtol(const char *cp, unsigned int base, long *res) 353d2f312e0SHans Petter Selasky { 354d2f312e0SHans Petter Selasky char *end; 355d2f312e0SHans Petter Selasky 356d2f312e0SHans Petter Selasky *res = strtol(cp, &end, base); 357d2f312e0SHans Petter Selasky 358cbfc3c73SHans Petter Selasky /* skip newline character, if any */ 359cbfc3c73SHans Petter Selasky if (*end == '\n') 360cbfc3c73SHans Petter Selasky end++; 361d2f312e0SHans Petter Selasky if (*cp == 0 || *end != 0) 362d2f312e0SHans Petter Selasky return (-EINVAL); 363d2f312e0SHans Petter Selasky return (0); 364d2f312e0SHans Petter Selasky } 365d2f312e0SHans Petter Selasky 366d2f312e0SHans Petter Selasky static inline int 367d2f312e0SHans Petter Selasky kstrtoint(const char *cp, unsigned int base, int *res) 368d2f312e0SHans Petter Selasky { 369d2f312e0SHans Petter Selasky char *end; 370d2f312e0SHans Petter Selasky long temp; 371d2f312e0SHans Petter Selasky 372d2f312e0SHans Petter Selasky *res = temp = strtol(cp, &end, base); 373d2f312e0SHans Petter Selasky 374cbfc3c73SHans Petter Selasky /* skip newline character, if any */ 375cbfc3c73SHans Petter Selasky if (*end == '\n') 376cbfc3c73SHans Petter Selasky end++; 377d2f312e0SHans Petter Selasky if (*cp == 0 || *end != 0) 378d2f312e0SHans Petter Selasky return (-EINVAL); 379d2f312e0SHans Petter Selasky if (temp != (int)temp) 380d2f312e0SHans Petter Selasky return (-ERANGE); 381d2f312e0SHans Petter Selasky return (0); 382d2f312e0SHans Petter Selasky } 383d2f312e0SHans Petter Selasky 384d2f312e0SHans Petter Selasky static inline int 385d2f312e0SHans Petter Selasky kstrtouint(const char *cp, unsigned int base, unsigned int *res) 386d2f312e0SHans Petter Selasky { 387d2f312e0SHans Petter Selasky char *end; 388d2f312e0SHans Petter Selasky unsigned long temp; 389d2f312e0SHans Petter Selasky 390d2f312e0SHans Petter Selasky *res = temp = strtoul(cp, &end, base); 391d2f312e0SHans Petter Selasky 392cbfc3c73SHans Petter Selasky /* skip newline character, if any */ 393cbfc3c73SHans Petter Selasky if (*end == '\n') 394cbfc3c73SHans Petter Selasky end++; 395d2f312e0SHans Petter Selasky if (*cp == 0 || *end != 0) 396d2f312e0SHans Petter Selasky return (-EINVAL); 397d2f312e0SHans Petter Selasky if (temp != (unsigned int)temp) 398d2f312e0SHans Petter Selasky return (-ERANGE); 399d2f312e0SHans Petter Selasky return (0); 400d2f312e0SHans Petter Selasky } 401d2f312e0SHans Petter Selasky 402d2f312e0SHans Petter Selasky static inline int 403b382b785SBjoern A. Zeeb kstrtou8(const char *cp, unsigned int base, u8 *res) 404b382b785SBjoern A. Zeeb { 405b382b785SBjoern A. Zeeb char *end; 406b382b785SBjoern A. Zeeb unsigned long temp; 407b382b785SBjoern A. Zeeb 408b382b785SBjoern A. Zeeb *res = temp = strtoul(cp, &end, base); 409b382b785SBjoern A. Zeeb 410b382b785SBjoern A. Zeeb /* skip newline character, if any */ 411b382b785SBjoern A. Zeeb if (*end == '\n') 412b382b785SBjoern A. Zeeb end++; 413b382b785SBjoern A. Zeeb if (*cp == 0 || *end != 0) 414b382b785SBjoern A. Zeeb return (-EINVAL); 415b382b785SBjoern A. Zeeb if (temp != (u8)temp) 416b382b785SBjoern A. Zeeb return (-ERANGE); 417b382b785SBjoern A. Zeeb return (0); 418b382b785SBjoern A. Zeeb } 419b382b785SBjoern A. Zeeb 420b382b785SBjoern A. Zeeb static inline int 4218e52f22bSEmmanuel Vadot kstrtou16(const char *cp, unsigned int base, u16 *res) 4228e52f22bSEmmanuel Vadot { 4238e52f22bSEmmanuel Vadot char *end; 4248e52f22bSEmmanuel Vadot unsigned long temp; 4258e52f22bSEmmanuel Vadot 4268e52f22bSEmmanuel Vadot *res = temp = strtoul(cp, &end, base); 4278e52f22bSEmmanuel Vadot 4288e52f22bSEmmanuel Vadot /* skip newline character, if any */ 4298e52f22bSEmmanuel Vadot if (*end == '\n') 4308e52f22bSEmmanuel Vadot end++; 4318e52f22bSEmmanuel Vadot if (*cp == 0 || *end != 0) 4328e52f22bSEmmanuel Vadot return (-EINVAL); 4338e52f22bSEmmanuel Vadot if (temp != (u16)temp) 4348e52f22bSEmmanuel Vadot return (-ERANGE); 4358e52f22bSEmmanuel Vadot return (0); 4368e52f22bSEmmanuel Vadot } 4378e52f22bSEmmanuel Vadot 4388e52f22bSEmmanuel Vadot static inline int 439d2f312e0SHans Petter Selasky kstrtou32(const char *cp, unsigned int base, u32 *res) 440d2f312e0SHans Petter Selasky { 441d2f312e0SHans Petter Selasky 442f82cf28bSBjoern A. Zeeb return (kstrtouint(cp, base, res)); 443d2f312e0SHans Petter Selasky } 4448d59ecb2SHans Petter Selasky 44535555d47SHans Petter Selasky static inline int 44661f7fe6bSHans Petter Selasky kstrtou64(const char *cp, unsigned int base, u64 *res) 44761f7fe6bSHans Petter Selasky { 44861f7fe6bSHans Petter Selasky char *end; 44961f7fe6bSHans Petter Selasky 45061f7fe6bSHans Petter Selasky *res = strtouq(cp, &end, base); 45161f7fe6bSHans Petter Selasky 45261f7fe6bSHans Petter Selasky /* skip newline character, if any */ 45361f7fe6bSHans Petter Selasky if (*end == '\n') 45461f7fe6bSHans Petter Selasky end++; 45561f7fe6bSHans Petter Selasky if (*cp == 0 || *end != 0) 45661f7fe6bSHans Petter Selasky return (-EINVAL); 45761f7fe6bSHans Petter Selasky return (0); 45861f7fe6bSHans Petter Selasky } 45961f7fe6bSHans Petter Selasky 46061f7fe6bSHans Petter Selasky static inline int 461c427456fSVladimir Kondratyev kstrtoull(const char *cp, unsigned int base, unsigned long long *res) 462c427456fSVladimir Kondratyev { 463c427456fSVladimir Kondratyev return (kstrtou64(cp, base, (u64 *)res)); 464c427456fSVladimir Kondratyev } 465c427456fSVladimir Kondratyev 466c427456fSVladimir Kondratyev static inline int 46735555d47SHans Petter Selasky kstrtobool(const char *s, bool *res) 46835555d47SHans Petter Selasky { 46935555d47SHans Petter Selasky int len; 47035555d47SHans Petter Selasky 47135555d47SHans Petter Selasky if (s == NULL || (len = strlen(s)) == 0 || res == NULL) 47235555d47SHans Petter Selasky return (-EINVAL); 47335555d47SHans Petter Selasky 47435555d47SHans Petter Selasky /* skip newline character, if any */ 47535555d47SHans Petter Selasky if (s[len - 1] == '\n') 47635555d47SHans Petter Selasky len--; 47735555d47SHans Petter Selasky 47835555d47SHans Petter Selasky if (len == 1 && strchr("yY1", s[0]) != NULL) 47935555d47SHans Petter Selasky *res = true; 48035555d47SHans Petter Selasky else if (len == 1 && strchr("nN0", s[0]) != NULL) 48135555d47SHans Petter Selasky *res = false; 48235555d47SHans Petter Selasky else if (strncasecmp("on", s, len) == 0) 48335555d47SHans Petter Selasky *res = true; 48435555d47SHans Petter Selasky else if (strncasecmp("off", s, len) == 0) 48535555d47SHans Petter Selasky *res = false; 48635555d47SHans Petter Selasky else 48735555d47SHans Petter Selasky return (-EINVAL); 48835555d47SHans Petter Selasky 48935555d47SHans Petter Selasky return (0); 49035555d47SHans Petter Selasky } 49135555d47SHans Petter Selasky 49235555d47SHans Petter Selasky static inline int 49335555d47SHans Petter Selasky kstrtobool_from_user(const char __user *s, size_t count, bool *res) 49435555d47SHans Petter Selasky { 49535555d47SHans Petter Selasky char buf[8] = {}; 49635555d47SHans Petter Selasky 49735555d47SHans Petter Selasky if (count > (sizeof(buf) - 1)) 49835555d47SHans Petter Selasky count = (sizeof(buf) - 1); 49935555d47SHans Petter Selasky 50035555d47SHans Petter Selasky if (copy_from_user(buf, s, count)) 50135555d47SHans Petter Selasky return (-EFAULT); 50235555d47SHans Petter Selasky 50335555d47SHans Petter Selasky return (kstrtobool(buf, res)); 50435555d47SHans Petter Selasky } 50535555d47SHans Petter Selasky 506b382b785SBjoern A. Zeeb static inline int 507c840d5ceSBjoern A. Zeeb kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, 508c840d5ceSBjoern A. Zeeb int *p) 509c840d5ceSBjoern A. Zeeb { 510c840d5ceSBjoern A. Zeeb char buf[36] = {}; 511c840d5ceSBjoern A. Zeeb 512c840d5ceSBjoern A. Zeeb if (count > (sizeof(buf) - 1)) 513c840d5ceSBjoern A. Zeeb count = (sizeof(buf) - 1); 514c840d5ceSBjoern A. Zeeb 515c840d5ceSBjoern A. Zeeb if (copy_from_user(buf, s, count)) 516c840d5ceSBjoern A. Zeeb return (-EFAULT); 517c840d5ceSBjoern A. Zeeb 518c840d5ceSBjoern A. Zeeb return (kstrtoint(buf, base, p)); 519c840d5ceSBjoern A. Zeeb } 520c840d5ceSBjoern A. Zeeb 521c840d5ceSBjoern A. Zeeb static inline int 5228e587a5fSEmmanuel Vadot kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, 523f82cf28bSBjoern A. Zeeb unsigned int *p) 5248e587a5fSEmmanuel Vadot { 5258e587a5fSEmmanuel Vadot char buf[36] = {}; 5268e587a5fSEmmanuel Vadot 5278e587a5fSEmmanuel Vadot if (count > (sizeof(buf) - 1)) 5288e587a5fSEmmanuel Vadot count = (sizeof(buf) - 1); 5298e587a5fSEmmanuel Vadot 5308e587a5fSEmmanuel Vadot if (copy_from_user(buf, s, count)) 5318e587a5fSEmmanuel Vadot return (-EFAULT); 5328e587a5fSEmmanuel Vadot 5338e587a5fSEmmanuel Vadot return (kstrtouint(buf, base, p)); 5348e587a5fSEmmanuel Vadot } 5358e587a5fSEmmanuel Vadot 5368e587a5fSEmmanuel Vadot static inline int 537f82cf28bSBjoern A. Zeeb kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, 538f82cf28bSBjoern A. Zeeb unsigned int *p) 539f82cf28bSBjoern A. Zeeb { 540f82cf28bSBjoern A. Zeeb 541f82cf28bSBjoern A. Zeeb return (kstrtouint_from_user(s, count, base, p)); 542f82cf28bSBjoern A. Zeeb } 543f82cf28bSBjoern A. Zeeb 544f82cf28bSBjoern A. Zeeb static inline int 545b382b785SBjoern A. Zeeb kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, 546b382b785SBjoern A. Zeeb u8 *p) 547b382b785SBjoern A. Zeeb { 548b382b785SBjoern A. Zeeb char buf[8] = {}; 549b382b785SBjoern A. Zeeb 550b382b785SBjoern A. Zeeb if (count > (sizeof(buf) - 1)) 551b382b785SBjoern A. Zeeb count = (sizeof(buf) - 1); 552b382b785SBjoern A. Zeeb 553b382b785SBjoern A. Zeeb if (copy_from_user(buf, s, count)) 554b382b785SBjoern A. Zeeb return (-EFAULT); 555b382b785SBjoern A. Zeeb 556b382b785SBjoern A. Zeeb return (kstrtou8(buf, base, p)); 557b382b785SBjoern A. Zeeb } 558b382b785SBjoern A. Zeeb 5598d59ecb2SHans Petter Selasky #define min(x, y) ((x) < (y) ? (x) : (y)) 5608d59ecb2SHans Petter Selasky #define max(x, y) ((x) > (y) ? (x) : (y)) 5618d59ecb2SHans Petter Selasky 5628d59ecb2SHans Petter Selasky #define min3(a, b, c) min(a, min(b,c)) 5638d59ecb2SHans Petter Selasky #define max3(a, b, c) max(a, max(b,c)) 5648d59ecb2SHans Petter Selasky 565abb14a54SHans Petter Selasky #define min_t(type, x, y) ({ \ 566abb14a54SHans Petter Selasky type __min1 = (x); \ 567abb14a54SHans Petter Selasky type __min2 = (y); \ 568abb14a54SHans Petter Selasky __min1 < __min2 ? __min1 : __min2; }) 569abb14a54SHans Petter Selasky 570abb14a54SHans Petter Selasky #define max_t(type, x, y) ({ \ 571abb14a54SHans Petter Selasky type __max1 = (x); \ 572abb14a54SHans Petter Selasky type __max2 = (y); \ 573abb14a54SHans Petter Selasky __max1 > __max2 ? __max1 : __max2; }) 5748d59ecb2SHans Petter Selasky 575355711eaSEmmanuel Vadot #define offsetofend(t, m) \ 576355711eaSEmmanuel Vadot (offsetof(t, m) + sizeof((((t *)0)->m))) 577355711eaSEmmanuel Vadot 578d3584f92SJean-Sébastien Pédron #define typeof_member(s, e) typeof(((s *)0)->e) 579d3584f92SJean-Sébastien Pédron 5808d59ecb2SHans Petter Selasky #define clamp_t(type, _x, min, max) min_t(type, max_t(type, _x, min), max) 5818d59ecb2SHans Petter Selasky #define clamp(x, lo, hi) min( max(x,lo), hi) 582abb14a54SHans Petter Selasky #define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi) 5838d59ecb2SHans Petter Selasky 5848d59ecb2SHans Petter Selasky /* 5858d59ecb2SHans Petter Selasky * This looks more complex than it should be. But we need to 5868d59ecb2SHans Petter Selasky * get the type for the ~ right in round_down (it needs to be 5878d59ecb2SHans Petter Selasky * as wide as the result!), and we want to evaluate the macro 5888d59ecb2SHans Petter Selasky * arguments just once each. 5898d59ecb2SHans Petter Selasky */ 5908d59ecb2SHans Petter Selasky #define __round_mask(x, y) ((__typeof__(x))((y)-1)) 5918d59ecb2SHans Petter Selasky #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) 5928d59ecb2SHans Petter Selasky #define round_down(x, y) ((x) & ~__round_mask(x, y)) 5938d59ecb2SHans Petter Selasky 594fe68f570SHans Petter Selasky #define smp_processor_id() PCPU_GET(cpuid) 5958d59ecb2SHans Petter Selasky #define num_possible_cpus() mp_ncpus 5968d59ecb2SHans Petter Selasky #define num_online_cpus() mp_ncpus 59703219fbaSHans Petter Selasky 59803219fbaSHans Petter Selasky #if defined(__i386__) || defined(__amd64__) 59903219fbaSHans Petter Selasky extern bool linux_cpu_has_clflush; 60003219fbaSHans Petter Selasky #define cpu_has_clflush linux_cpu_has_clflush 60103219fbaSHans Petter Selasky #endif 6028d59ecb2SHans Petter Selasky 6038d59ecb2SHans Petter Selasky /* Swap values of a and b */ 6048d59ecb2SHans Petter Selasky #define swap(a, b) do { \ 6058d59ecb2SHans Petter Selasky typeof(a) _swap_tmp = a; \ 6068d59ecb2SHans Petter Selasky a = b; \ 6078d59ecb2SHans Petter Selasky b = _swap_tmp; \ 6088d59ecb2SHans Petter Selasky } while (0) 6098d59ecb2SHans Petter Selasky 6108d59ecb2SHans Petter Selasky #define DIV_ROUND_CLOSEST(x, divisor) (((x) + ((divisor) / 2)) / (divisor)) 6118d59ecb2SHans Petter Selasky 612abb14a54SHans Petter Selasky #define DIV_ROUND_CLOSEST_ULL(x, divisor) ({ \ 613abb14a54SHans Petter Selasky __typeof(divisor) __d = (divisor); \ 614abb14a54SHans Petter Selasky unsigned long long __ret = (x) + (__d) / 2; \ 615abb14a54SHans Petter Selasky __ret /= __d; \ 616abb14a54SHans Petter Selasky __ret; \ 617abb14a54SHans Petter Selasky }) 618abb14a54SHans Petter Selasky 6198d59ecb2SHans Petter Selasky static inline uintmax_t 6208d59ecb2SHans Petter Selasky mult_frac(uintmax_t x, uintmax_t multiplier, uintmax_t divisor) 6218d59ecb2SHans Petter Selasky { 6228d59ecb2SHans Petter Selasky uintmax_t q = (x / divisor); 6238d59ecb2SHans Petter Selasky uintmax_t r = (x % divisor); 6248d59ecb2SHans Petter Selasky 6258d59ecb2SHans Petter Selasky return ((q * multiplier) + ((r * multiplier) / divisor)); 6268d59ecb2SHans Petter Selasky } 6278d59ecb2SHans Petter Selasky 6288d59ecb2SHans Petter Selasky static inline int64_t 6298d59ecb2SHans Petter Selasky abs64(int64_t x) 6308d59ecb2SHans Petter Selasky { 6318d59ecb2SHans Petter Selasky return (x < 0 ? -x : x); 6328d59ecb2SHans Petter Selasky } 6338d59ecb2SHans Petter Selasky 6348f7eee5aSHans Petter Selasky typedef struct linux_ratelimit { 6358f7eee5aSHans Petter Selasky struct timeval lasttime; 6368f7eee5aSHans Petter Selasky int counter; 6378f7eee5aSHans Petter Selasky } linux_ratelimit_t; 6388f7eee5aSHans Petter Selasky 6398f7eee5aSHans Petter Selasky static inline bool 6408f7eee5aSHans Petter Selasky linux_ratelimited(linux_ratelimit_t *rl) 6418f7eee5aSHans Petter Selasky { 6428f7eee5aSHans Petter Selasky return (ppsratecheck(&rl->lasttime, &rl->counter, 1)); 6438f7eee5aSHans Petter Selasky } 644e9db3df2SHans Petter Selasky 645ef5f8c18SHans Petter Selasky #define struct_size(ptr, field, num) ({ \ 646ef5f8c18SHans Petter Selasky const size_t __size = offsetof(__typeof(*(ptr)), field); \ 647ef5f8c18SHans Petter Selasky const size_t __max = (SIZE_MAX - __size) / sizeof((ptr)->field[0]); \ 648ef5f8c18SHans Petter Selasky ((num) > __max) ? SIZE_MAX : (__size + sizeof((ptr)->field[0]) * (num)); \ 649ef5f8c18SHans Petter Selasky }) 650ef5f8c18SHans Petter Selasky 651d053391cSHans Petter Selasky #define __is_constexpr(x) \ 652d053391cSHans Petter Selasky __builtin_constant_p(x) 653d053391cSHans Petter Selasky 654d326a6c7SHans Petter Selasky /* 655d326a6c7SHans Petter Selasky * The is_signed() macro below returns true if the passed data type is 656d326a6c7SHans Petter Selasky * signed. Else false is returned. 657d326a6c7SHans Petter Selasky */ 658d326a6c7SHans Petter Selasky #define is_signed(datatype) (((datatype)-1 / (datatype)2) == (datatype)0) 659d0eed838SHans Petter Selasky 660d326a6c7SHans Petter Selasky /* 661d326a6c7SHans Petter Selasky * The type_max() macro below returns the maxium positive value the 662d326a6c7SHans Petter Selasky * passed data type can hold. 663d326a6c7SHans Petter Selasky */ 664d326a6c7SHans Petter Selasky #define type_max(datatype) ( \ 665d326a6c7SHans Petter Selasky (sizeof(datatype) >= 8) ? (is_signed(datatype) ? INT64_MAX : UINT64_MAX) : \ 666d326a6c7SHans Petter Selasky (sizeof(datatype) >= 4) ? (is_signed(datatype) ? INT32_MAX : UINT32_MAX) : \ 667d326a6c7SHans Petter Selasky (sizeof(datatype) >= 2) ? (is_signed(datatype) ? INT16_MAX : UINT16_MAX) : \ 668d326a6c7SHans Petter Selasky (is_signed(datatype) ? INT8_MAX : UINT8_MAX) \ 669d0eed838SHans Petter Selasky ) 670d0eed838SHans Petter Selasky 671d326a6c7SHans Petter Selasky /* 672d326a6c7SHans Petter Selasky * The type_min() macro below returns the minimum value the passed 673d326a6c7SHans Petter Selasky * data type can hold. For unsigned types the minimum value is always 674d326a6c7SHans Petter Selasky * zero. For signed types it may vary. 675d326a6c7SHans Petter Selasky */ 676d326a6c7SHans Petter Selasky #define type_min(datatype) ( \ 677d326a6c7SHans Petter Selasky (sizeof(datatype) >= 8) ? (is_signed(datatype) ? INT64_MIN : 0) : \ 678d326a6c7SHans Petter Selasky (sizeof(datatype) >= 4) ? (is_signed(datatype) ? INT32_MIN : 0) : \ 679d326a6c7SHans Petter Selasky (sizeof(datatype) >= 2) ? (is_signed(datatype) ? INT16_MIN : 0) : \ 680d326a6c7SHans Petter Selasky (is_signed(datatype) ? INT8_MIN : 0) \ 681d0eed838SHans Petter Selasky ) 682d0eed838SHans Petter Selasky 6830e4e9e8fSEmmanuel Vadot #define TAINT_WARN 0 6840e4e9e8fSEmmanuel Vadot #define test_taint(x) (0) 685bf27839aSEmmanuel Vadot #define add_taint(x,y) do { \ 686bf27839aSEmmanuel Vadot } while (0) 6870e4e9e8fSEmmanuel Vadot 688deb9bfbdSBjoern A. Zeeb static inline int 689deb9bfbdSBjoern A. Zeeb _h2b(const char c) 690deb9bfbdSBjoern A. Zeeb { 691deb9bfbdSBjoern A. Zeeb 692deb9bfbdSBjoern A. Zeeb if (c >= '0' && c <= '9') 693deb9bfbdSBjoern A. Zeeb return (c - '0'); 694deb9bfbdSBjoern A. Zeeb if (c >= 'a' && c <= 'f') 695deb9bfbdSBjoern A. Zeeb return (10 + c - 'a'); 696deb9bfbdSBjoern A. Zeeb if (c >= 'A' && c <= 'F') 697deb9bfbdSBjoern A. Zeeb return (10 + c - 'A'); 698deb9bfbdSBjoern A. Zeeb return (-EINVAL); 699deb9bfbdSBjoern A. Zeeb } 700deb9bfbdSBjoern A. Zeeb 701deb9bfbdSBjoern A. Zeeb static inline int 702deb9bfbdSBjoern A. Zeeb hex2bin(uint8_t *bindst, const char *hexsrc, size_t binlen) 703deb9bfbdSBjoern A. Zeeb { 704deb9bfbdSBjoern A. Zeeb int hi4, lo4; 705deb9bfbdSBjoern A. Zeeb 706deb9bfbdSBjoern A. Zeeb while (binlen > 0) { 707deb9bfbdSBjoern A. Zeeb hi4 = _h2b(*hexsrc++); 708deb9bfbdSBjoern A. Zeeb lo4 = _h2b(*hexsrc++); 709deb9bfbdSBjoern A. Zeeb if (hi4 < 0 || lo4 < 0) 710deb9bfbdSBjoern A. Zeeb return (-EINVAL); 711deb9bfbdSBjoern A. Zeeb 712deb9bfbdSBjoern A. Zeeb *bindst++ = (hi4 << 4) | lo4; 713deb9bfbdSBjoern A. Zeeb binlen--; 714deb9bfbdSBjoern A. Zeeb } 715deb9bfbdSBjoern A. Zeeb 716deb9bfbdSBjoern A. Zeeb return (0); 717deb9bfbdSBjoern A. Zeeb } 718deb9bfbdSBjoern A. Zeeb 719f82cf28bSBjoern A. Zeeb static inline bool 720f82cf28bSBjoern A. Zeeb mac_pton(const char *macin, uint8_t *macout) 721f82cf28bSBjoern A. Zeeb { 722f82cf28bSBjoern A. Zeeb const char *s, *d; 723f82cf28bSBjoern A. Zeeb uint8_t mac[6], hx, lx;; 724f82cf28bSBjoern A. Zeeb int i; 725f82cf28bSBjoern A. Zeeb 726f82cf28bSBjoern A. Zeeb if (strlen(macin) < (3 * 6 - 1)) 727f82cf28bSBjoern A. Zeeb return (false); 728f82cf28bSBjoern A. Zeeb 729f82cf28bSBjoern A. Zeeb i = 0; 730f82cf28bSBjoern A. Zeeb s = macin; 731f82cf28bSBjoern A. Zeeb do { 732f82cf28bSBjoern A. Zeeb /* Should we also support '-'-delimiters? */ 733f82cf28bSBjoern A. Zeeb d = strchrnul(s, ':'); 734f82cf28bSBjoern A. Zeeb hx = lx = 0; 735f82cf28bSBjoern A. Zeeb while (s < d) { 736f82cf28bSBjoern A. Zeeb /* Fail on abc:123:xxx:... */ 737f82cf28bSBjoern A. Zeeb if ((d - s) > 2) 738f82cf28bSBjoern A. Zeeb return (false); 739f82cf28bSBjoern A. Zeeb /* We do support non-well-formed strings: 3:45:6:... */ 740f82cf28bSBjoern A. Zeeb if ((d - s) > 1) { 741f82cf28bSBjoern A. Zeeb hx = _h2b(*s); 742f82cf28bSBjoern A. Zeeb if (hx < 0) 743f82cf28bSBjoern A. Zeeb return (false); 744f82cf28bSBjoern A. Zeeb s++; 745f82cf28bSBjoern A. Zeeb } 746f82cf28bSBjoern A. Zeeb lx = _h2b(*s); 747f82cf28bSBjoern A. Zeeb if (lx < 0) 748f82cf28bSBjoern A. Zeeb return (false); 749f82cf28bSBjoern A. Zeeb s++; 750f82cf28bSBjoern A. Zeeb } 751f82cf28bSBjoern A. Zeeb mac[i] = (hx << 4) | lx; 752f82cf28bSBjoern A. Zeeb i++; 753f82cf28bSBjoern A. Zeeb if (i >= 6) 754f82cf28bSBjoern A. Zeeb return (false); 755f82cf28bSBjoern A. Zeeb } while (d != NULL && *d != '\0'); 756f82cf28bSBjoern A. Zeeb 757f82cf28bSBjoern A. Zeeb memcpy(macout, mac, 6); 758f82cf28bSBjoern A. Zeeb return (true); 759f82cf28bSBjoern A. Zeeb } 760f82cf28bSBjoern A. Zeeb 761c840d5ceSBjoern A. Zeeb #define DECLARE_FLEX_ARRAY(_t, _n) \ 762fab601c5SBjoern A. Zeeb struct { struct { } __dummy_ ## _n; _t _n[0]; } 763c840d5ceSBjoern A. Zeeb 764307f78f3SVladimir Kondratyev #endif /* _LINUXKPI_LINUX_KERNEL_H_ */ 765