1#ifndef _LINUX_KERNEL_H
2#define _LINUX_KERNEL_H
3
4
5#include <stdarg.h>
6#include <linux/linkage.h>
7#include <linux/stddef.h>
8#include <linux/types.h>
9#include <linux/compiler.h>
10#include <linux/bitops.h>
11#include <linux/log2.h>
12#include <linux/typecheck.h>
13#include <linux/printk.h>
14#include <linux/dynamic_debug.h>
15#include <asm/byteorder.h>
16#include <uapi/linux/kernel.h>
17
18#define USHRT_MAX ((u16)(~0U))
19#define SHRT_MAX ((s16)(USHRT_MAX>>1))
20#define SHRT_MIN ((s16)(-SHRT_MAX - 1))
21#define INT_MAX ((int)(~0U>>1))
22#define INT_MIN (-INT_MAX - 1)
23#define UINT_MAX (~0U)
24#define LONG_MAX ((long)(~0UL>>1))
25#define LONG_MIN (-LONG_MAX - 1)
26#define ULONG_MAX (~0UL)
27#define LLONG_MAX ((long long)(~0ULL>>1))
28#define LLONG_MIN (-LLONG_MAX - 1)
29#define ULLONG_MAX (~0ULL)
30#define SIZE_MAX (~(size_t)0)
31
32#define STACK_MAGIC 0xdeadbeef
33
34#define REPEAT_BYTE(x) ((~0ul / 0xff) * (x))
35
36#define ALIGN(x, a) __ALIGN_KERNEL((x), (a))
37#define __ALIGN_MASK(x, mask) __ALIGN_KERNEL_MASK((x), (mask))
38#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a)))
39#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0)
40
41#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
42
43
44
45
46
47
48
49#define __round_mask(x, y) ((__typeof__(x))((y)-1))
50#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
51#define round_down(x, y) ((x) & ~__round_mask(x, y))
52
53#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
54#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
55#define DIV_ROUND_UP_ULL(ll,d) \
56 ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
57
58#if BITS_PER_LONG == 32
59# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
60#else
61# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
62#endif
63
64
65#define roundup(x, y) ( \
66{ \
67 const typeof(y) __y = y; \
68 (((x) + (__y - 1)) / __y) * __y; \
69} \
70)
71#define rounddown(x, y) ( \
72{ \
73 typeof(x) __x = (x); \
74 __x - (__x % (y)); \
75} \
76)
77
78
79
80
81
82
83#define DIV_ROUND_CLOSEST(x, divisor)( \
84{ \
85 typeof(x) __x = x; \
86 typeof(divisor) __d = divisor; \
87 (((typeof(x))-1) > 0 || \
88 ((typeof(divisor))-1) > 0 || (__x) > 0) ? \
89 (((__x) + ((__d) / 2)) / (__d)) : \
90 (((__x) - ((__d) / 2)) / (__d)); \
91} \
92)
93
94
95
96
97
98#define mult_frac(x, numer, denom)( \
99{ \
100 typeof(x) quot = (x) / (denom); \
101 typeof(x) rem = (x) % (denom); \
102 (quot * (numer)) + ((rem * (numer)) / (denom)); \
103} \
104)
105
106
107#define _RET_IP_ (unsigned long)__builtin_return_address(0)
108#define _THIS_IP_ ({ __label__ __here; __here: (unsigned long)&&__here; })
109
110#ifdef CONFIG_LBDAF
111# include <asm/div64.h>
112# define sector_div(a, b) do_div(a, b)
113#else
114# define sector_div(n, b)( \
115{ \
116 int _res; \
117 _res = (n) % (b); \
118 (n) /= (b); \
119 _res; \
120} \
121)
122#endif
123
124
125
126
127
128
129
130
131
132#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
133
134
135
136
137
138#define lower_32_bits(n) ((u32)(n))
139
140struct completion;
141struct pt_regs;
142struct user;
143
144#ifdef CONFIG_PREEMPT_VOLUNTARY
145extern int _cond_resched(void);
146# define might_resched() _cond_resched()
147#else
148# define might_resched() do { } while (0)
149#endif
150
151#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
152 void __might_sleep(const char *file, int line, int preempt_offset);
153
154
155
156
157
158
159
160
161
162
163# define might_sleep() \
164 do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
165#else
166 static inline void __might_sleep(const char *file, int line,
167 int preempt_offset) { }
168# define might_sleep() do { might_resched(); } while (0)
169#endif
170
171#define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
172
173
174
175
176
177
178
179#define abs(x) ({ \
180 long ret; \
181 if (sizeof(x) == sizeof(long)) { \
182 long __x = (x); \
183 ret = (__x < 0) ? -__x : __x; \
184 } else { \
185 int __x = (x); \
186 ret = (__x < 0) ? -__x : __x; \
187 } \
188 ret; \
189 })
190
191#define abs64(x) ({ \
192 s64 __x = (x); \
193 (__x < 0) ? -__x : __x; \
194 })
195
196#ifdef CONFIG_PROVE_LOCKING
197void might_fault(void);
198#else
199static inline void might_fault(void)
200{
201 might_sleep();
202}
203#endif
204
205extern struct atomic_notifier_head panic_notifier_list;
206extern long (*panic_blink)(int state);
207__printf(1, 2)
208void panic(const char *fmt, ...)
209 __noreturn __cold;
210extern void oops_enter(void);
211extern void oops_exit(void);
212void print_oops_end_marker(void);
213extern int oops_may_print(void);
214void do_exit(long error_code)
215 __noreturn;
216void complete_and_exit(struct completion *, long)
217 __noreturn;
218
219
220int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
221int __must_check _kstrtol(const char *s, unsigned int base, long *res);
222
223int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
224int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
243{
244
245
246
247
248 if (sizeof(unsigned long) == sizeof(unsigned long long) &&
249 __alignof__(unsigned long) == __alignof__(unsigned long long))
250 return kstrtoull(s, base, (unsigned long long *)res);
251 else
252 return _kstrtoul(s, base, res);
253}
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
272{
273
274
275
276
277 if (sizeof(long) == sizeof(long long) &&
278 __alignof__(long) == __alignof__(long long))
279 return kstrtoll(s, base, (long long *)res);
280 else
281 return _kstrtol(s, base, res);
282}
283
284int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res);
285int __must_check kstrtoint(const char *s, unsigned int base, int *res);
286
287static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res)
288{
289 return kstrtoull(s, base, res);
290}
291
292static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res)
293{
294 return kstrtoll(s, base, res);
295}
296
297static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res)
298{
299 return kstrtouint(s, base, res);
300}
301
302static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res)
303{
304 return kstrtoint(s, base, res);
305}
306
307int __must_check kstrtou16(const char *s, unsigned int base, u16 *res);
308int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
309int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
310int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
311
312int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res);
313int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res);
314int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res);
315int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res);
316int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res);
317int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res);
318int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res);
319int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res);
320int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res);
321int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res);
322
323static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res)
324{
325 return kstrtoull_from_user(s, count, base, res);
326}
327
328static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res)
329{
330 return kstrtoll_from_user(s, count, base, res);
331}
332
333static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res)
334{
335 return kstrtouint_from_user(s, count, base, res);
336}
337
338static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res)
339{
340 return kstrtoint_from_user(s, count, base, res);
341}
342
343
344
345extern unsigned long simple_strtoul(const char *,char **,unsigned int);
346extern long simple_strtol(const char *,char **,unsigned int);
347extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
348extern long long simple_strtoll(const char *,char **,unsigned int);
349#define strict_strtoul kstrtoul
350#define strict_strtol kstrtol
351#define strict_strtoull kstrtoull
352#define strict_strtoll kstrtoll
353
354extern int num_to_str(char *buf, int size, unsigned long long num);
355
356
357
358extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
359extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list);
360extern __printf(3, 4)
361int snprintf(char *buf, size_t size, const char *fmt, ...);
362extern __printf(3, 0)
363int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
364extern __printf(3, 4)
365int scnprintf(char *buf, size_t size, const char *fmt, ...);
366extern __printf(3, 0)
367int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
368extern __printf(2, 3)
369char *kasprintf(gfp_t gfp, const char *fmt, ...);
370extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
371
372extern __scanf(2, 3)
373int sscanf(const char *, const char *, ...);
374extern __scanf(2, 0)
375int vsscanf(const char *, const char *, va_list);
376
377extern int get_option(char **str, int *pint);
378extern char *get_options(const char *str, int nints, int *ints);
379extern unsigned long long memparse(const char *ptr, char **retptr);
380
381extern int core_kernel_text(unsigned long addr);
382extern int core_kernel_data(unsigned long addr);
383extern int __kernel_text_address(unsigned long addr);
384extern int kernel_text_address(unsigned long addr);
385extern int func_ptr_is_kernel_text(void *ptr);
386
387struct pid;
388extern struct pid *session_of_pgrp(struct pid *pgrp);
389
390unsigned long int_sqrt(unsigned long);
391
392extern void bust_spinlocks(int yes);
393extern int oops_in_progress;
394extern int panic_timeout;
395extern int panic_on_oops;
396extern int panic_on_unrecovered_nmi;
397extern int panic_on_io_nmi;
398extern int sysctl_panic_on_stackoverflow;
399extern const char *print_tainted(void);
400enum lockdep_ok {
401 LOCKDEP_STILL_OK,
402 LOCKDEP_NOW_UNRELIABLE
403};
404extern void add_taint(unsigned flag, enum lockdep_ok);
405extern int test_taint(unsigned flag);
406extern unsigned long get_taint(void);
407extern int root_mountflags;
408
409extern bool early_boot_irqs_disabled;
410
411
412extern enum system_states {
413 SYSTEM_BOOTING,
414 SYSTEM_RUNNING,
415 SYSTEM_HALT,
416 SYSTEM_POWER_OFF,
417 SYSTEM_RESTART,
418} system_state;
419
420#define TAINT_PROPRIETARY_MODULE 0
421#define TAINT_FORCED_MODULE 1
422#define TAINT_UNSAFE_SMP 2
423#define TAINT_FORCED_RMMOD 3
424#define TAINT_MACHINE_CHECK 4
425#define TAINT_BAD_PAGE 5
426#define TAINT_USER 6
427#define TAINT_DIE 7
428#define TAINT_OVERRIDDEN_ACPI_TABLE 8
429#define TAINT_WARN 9
430#define TAINT_CRAP 10
431#define TAINT_FIRMWARE_WORKAROUND 11
432#define TAINT_OOT_MODULE 12
433
434extern const char hex_asc[];
435#define hex_asc_lo(x) hex_asc[((x) & 0x0f)]
436#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4]
437
438static inline char *hex_byte_pack(char *buf, u8 byte)
439{
440 *buf++ = hex_asc_hi(byte);
441 *buf++ = hex_asc_lo(byte);
442 return buf;
443}
444
445static inline char * __deprecated pack_hex_byte(char *buf, u8 byte)
446{
447 return hex_byte_pack(buf, byte);
448}
449
450extern int hex_to_bin(char ch);
451extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472#ifdef CONFIG_RING_BUFFER
473
474void tracing_off_permanent(void);
475#else
476static inline void tracing_off_permanent(void) { }
477#endif
478
479enum ftrace_dump_mode {
480 DUMP_NONE,
481 DUMP_ALL,
482 DUMP_ORIG,
483};
484
485#ifdef CONFIG_TRACING
486void tracing_on(void);
487void tracing_off(void);
488int tracing_is_on(void);
489void tracing_snapshot(void);
490void tracing_snapshot_alloc(void);
491
492extern void tracing_start(void);
493extern void tracing_stop(void);
494extern void ftrace_off_permanent(void);
495
496static inline __printf(1, 2)
497void ____trace_printk_check_format(const char *fmt, ...)
498{
499}
500#define __trace_printk_check_format(fmt, args...) \
501do { \
502 if (0) \
503 ____trace_printk_check_format(fmt, ##args); \
504} while (0)
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536#define trace_printk(fmt, ...) \
537do { \
538 char _______STR[] = __stringify((__VA_ARGS__)); \
539 if (sizeof(_______STR) > 3) \
540 do_trace_printk(fmt, ##__VA_ARGS__); \
541 else \
542 trace_puts(fmt); \
543} while (0)
544
545#define do_trace_printk(fmt, args...) \
546do { \
547 static const char *trace_printk_fmt \
548 __attribute__((section("__trace_printk_fmt"))) = \
549 __builtin_constant_p(fmt) ? fmt : NULL; \
550 \
551 __trace_printk_check_format(fmt, ##args); \
552 \
553 if (__builtin_constant_p(fmt)) \
554 __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args); \
555 else \
556 __trace_printk(_THIS_IP_, fmt, ##args); \
557} while (0)
558
559extern __printf(2, 3)
560int __trace_bprintk(unsigned long ip, const char *fmt, ...);
561
562extern __printf(2, 3)
563int __trace_printk(unsigned long ip, const char *fmt, ...);
564
565extern int __trace_bputs(unsigned long ip, const char *str);
566extern int __trace_puts(unsigned long ip, const char *str, int size);
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593#define trace_puts(str) ({ \
594 static const char *trace_printk_fmt \
595 __attribute__((section("__trace_printk_fmt"))) = \
596 __builtin_constant_p(str) ? str : NULL; \
597 \
598 if (__builtin_constant_p(str)) \
599 __trace_bputs(_THIS_IP_, trace_printk_fmt); \
600 else \
601 __trace_puts(_THIS_IP_, str, strlen(str)); \
602})
603
604extern void trace_dump_stack(int skip);
605
606
607
608
609
610
611#define ftrace_vprintk(fmt, vargs) \
612do { \
613 if (__builtin_constant_p(fmt)) { \
614 static const char *trace_printk_fmt \
615 __attribute__((section("__trace_printk_fmt"))) = \
616 __builtin_constant_p(fmt) ? fmt : NULL; \
617 \
618 __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs); \
619 } else \
620 __ftrace_vprintk(_THIS_IP_, fmt, vargs); \
621} while (0)
622
623extern int
624__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
625
626extern int
627__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
628
629extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
630#else
631static inline void tracing_start(void) { }
632static inline void tracing_stop(void) { }
633static inline void ftrace_off_permanent(void) { }
634static inline void trace_dump_stack(void) { }
635
636static inline void tracing_on(void) { }
637static inline void tracing_off(void) { }
638static inline int tracing_is_on(void) { return 0; }
639static inline void tracing_snapshot(void) { }
640static inline void tracing_snapshot_alloc(void) { }
641
642static inline __printf(1, 2)
643int trace_printk(const char *fmt, ...)
644{
645 return 0;
646}
647static inline int
648ftrace_vprintk(const char *fmt, va_list ap)
649{
650 return 0;
651}
652static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
653#endif
654
655
656
657
658
659
660#define min(x, y) ({ \
661 typeof(x) _min1 = (x); \
662 typeof(y) _min2 = (y); \
663 (void) (&_min1 == &_min2); \
664 _min1 < _min2 ? _min1 : _min2; })
665
666#define max(x, y) ({ \
667 typeof(x) _max1 = (x); \
668 typeof(y) _max2 = (y); \
669 (void) (&_max1 == &_max2); \
670 _max1 > _max2 ? _max1 : _max2; })
671
672#define min3(x, y, z) ({ \
673 typeof(x) _min1 = (x); \
674 typeof(y) _min2 = (y); \
675 typeof(z) _min3 = (z); \
676 (void) (&_min1 == &_min2); \
677 (void) (&_min1 == &_min3); \
678 _min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
679 (_min2 < _min3 ? _min2 : _min3); })
680
681#define max3(x, y, z) ({ \
682 typeof(x) _max1 = (x); \
683 typeof(y) _max2 = (y); \
684 typeof(z) _max3 = (z); \
685 (void) (&_max1 == &_max2); \
686 (void) (&_max1 == &_max3); \
687 _max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
688 (_max2 > _max3 ? _max2 : _max3); })
689
690
691
692
693
694
695#define min_not_zero(x, y) ({ \
696 typeof(x) __x = (x); \
697 typeof(y) __y = (y); \
698 __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
699
700
701
702
703
704
705
706
707
708
709#define clamp(val, min, max) ({ \
710 typeof(val) __val = (val); \
711 typeof(min) __min = (min); \
712 typeof(max) __max = (max); \
713 (void) (&__val == &__min); \
714 (void) (&__val == &__max); \
715 __val = __val < __min ? __min: __val; \
716 __val > __max ? __max: __val; })
717
718
719
720
721
722
723
724#define min_t(type, x, y) ({ \
725 type __min1 = (x); \
726 type __min2 = (y); \
727 __min1 < __min2 ? __min1: __min2; })
728
729#define max_t(type, x, y) ({ \
730 type __max1 = (x); \
731 type __max2 = (y); \
732 __max1 > __max2 ? __max1: __max2; })
733
734
735
736
737
738
739
740
741
742
743
744#define clamp_t(type, val, min, max) ({ \
745 type __val = (val); \
746 type __min = (min); \
747 type __max = (max); \
748 __val = __val < __min ? __min: __val; \
749 __val > __max ? __max: __val; })
750
751
752
753
754
755
756
757
758
759
760
761
762#define clamp_val(val, min, max) ({ \
763 typeof(val) __val = (val); \
764 typeof(val) __min = (min); \
765 typeof(val) __max = (max); \
766 __val = __val < __min ? __min: __val; \
767 __val > __max ? __max: __val; })
768
769
770
771
772
773#define swap(a, b) \
774 do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
775
776
777
778
779
780
781
782
783#define container_of(ptr, type, member) ({ \
784 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
785 (type *)( (char *)__mptr - offsetof(type,member) );})
786
787
788#define __FUNCTION__ (__func__)
789
790
791#ifdef CONFIG_FTRACE_MCOUNT_RECORD
792# define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
793#endif
794
795#endif
796