WebSVN – Kolibri OS – Diff – /drivers/include/linux/kernel.h

 	 ((typeof(divisor))-1) > 0 || (__x) > 0) ?	\
 		(((__x) + ((__d) / 2)) / (__d)) :	\
 		(((__x) - ((__d) / 2)) / (__d));	\
-}                                                       \
+}							\
+)
+/*
+ * Same as above but for u64 dividends. divisor must be a 32-bit
+ * number.
+ */
+#define DIV_ROUND_CLOSEST_ULL(x, divisor)(		\
+{							\
+	typeof(divisor) __d = divisor;			\
+	unsigned long long _tmp = (x) + (__d) / 2;	\
+	do_div(_tmp, __d);				\
+	_tmp;						\
+}							\
+)
 /*
  * Multiplies an integer by a fraction, while avoiding unnecessary
  * overflow or loss of precision.
  * lower_32_bits - return bits 0-31 of a number
  * @n: the number we're accessing
  */
 #define lower_32_bits(n) ((u32)(n))
+#ifdef CONFIG_PREEMPT_VOLUNTARY
+extern int _cond_resched(void);
+# define might_resched() _cond_resched()
+#else
+# define might_resched() do { } while (0)
+#endif
+#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
+  void ___might_sleep(const char *file, int line, int preempt_offset);
+  void __might_sleep(const char *file, int line, int preempt_offset);
+/**
+ * might_sleep - annotation for functions that can sleep
-/*
+ *
+ * this macro will print a stack trace if it is executed in an atomic
+ * context (spinlock, irq-handler, ...).
- * abs() handles unsigned and signed longs, ints, shorts and chars.  For all
+ *
- * input types abs() returns a signed long.
+ * This is a useful debugging help to be able to catch problems early and not
+ * be bitten later when the calling function happens to sleep when it is not
+ * supposed to.
+ */
+# define might_sleep() \
+	do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
+# define sched_annotate_sleep()	(current->task_state_change = 0)
+#else
+  static inline void ___might_sleep(const char *file, int line,
+				   int preempt_offset) { }
+  static inline void __might_sleep(const char *file, int line,
+				   int preempt_offset) { }
+# define might_sleep() do { might_resched(); } while (0)
+# define sched_annotate_sleep() do { } while (0)
+#endif
+#define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
+/**
+ * abs - return absolute value of an argument
+ * @x: the value.  If it is unsigned type, it is converted to signed type first
+ *   (s64, long or int depending on its size).
+ *
- * abs() should not be used for 64-bit types (s64, u64, long long) - use abs64()
+ * Return: an absolute value of x.  If x is 64-bit, macro's return type is s64,
+ *   otherwise it is signed long.
- * for those.
+ */
+#define abs(x) __builtin_choose_expr(sizeof(x) == sizeof(s64), ({	\
+		s64 __x = (x);						\
- */
+		(__x < 0) ? -__x : __x;					\
-#define abs(x) ({						\
+	}), ({								\
-		long ret;					\
+		long ret;						\
-		if (sizeof(x) == sizeof(long)) {		\
+		if (sizeof(x) == sizeof(long)) {			\
-			long __x = (x);				\
+			long __x = (x);					\
-			ret = (__x < 0) ? -__x : __x;		\
+			ret = (__x < 0) ? -__x : __x;			\
-		} else {					\
+		} else {						\
-			int __x = (x);				\
+			int __x = (x);					\
-			ret = (__x < 0) ? -__x : __x;		\
+			ret = (__x < 0) ? -__x : __x;			\
-		}						\
+		}							\
+		ret;							\
+	}))
+/**
+ * reciprocal_scale - "scale" a value into range [0, ep_ro)
+ * @val: value
+ * @ep_ro: right open interval endpoint
+ *
+ * Perform a "reciprocal multiplication" in order to "scale" a value into
+ * range [0, ep_ro), where the upper interval endpoint is right-open.
+ * This is useful, e.g. for accessing a index of an array containing
+ * ep_ro elements, for example. Think of it as sort of modulus, only that
-		ret;						\
+ * the result isn't that of modulo. ;) Note that if initial input is a
+ * small value, then result will return 0.
+ *
+ * Return: a result based on val in interval [0, ep_ro).
-	})
+ */
+static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
+{
+	return (u32)(((u64) val * ep_ro) >> 32);
+}
+#if defined(CONFIG_MMU) && \
+	(defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP))
+#define might_fault() __might_fault(__FILE__, __LINE__)
-#define abs64(x) ({                             \
+void __might_fault(const char *file, int line);
-                s64 __x = (x);                  \
+#else
-                (__x < 0) ? -__x : __x;         \
+static inline void might_fault(void) { }
-        })
+#endif
 #define KERN_EMERG      "<0>"   /* system is unusable                   */
 #define KERN_ALERT      "<1>"   /* action must be taken immediately     */
 #define KERN_CRIT       "<2>"   /* critical conditions                  */
 #define KERN_ERR        "<3>"   /* error conditions                     */
+#define KERN_WARNING    "<4>"   /* warning conditions                   */
+#define KERN_NOTICE     "<5>"   /* normal but significant condition     */
+#define KERN_INFO       "<6>"   /* informational                        */
+#define KERN_DEBUG      "<7>"   /* debug-level messages                 */
+extern unsigned long simple_strtoul(const char *,char **,unsigned int);
+extern long simple_strtol(const char *,char **,unsigned int);
+extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
+extern long long simple_strtoll(const char *,char **,unsigned int);
-#define KERN_WARNING    "<4>"   /* warning conditions                   */
+extern int num_to_str(char *buf, int size, unsigned long long num);
 #define KERN_NOTICE     "<5>"   /* normal but significant condition     */
-#define KERN_INFO       "<6>"   /* informational                        */
+/* lib/printf utilities */
 #define KERN_DEBUG      "<7>"   /* debug-level messages                 */
 extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
 int scnprintf(char *buf, size_t size, const char *fmt, ...);
 extern __printf(3, 0)
 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
 extern __printf(2, 3)
 char *kasprintf(gfp_t gfp, const char *fmt, ...);
+extern __printf(2, 0)
-extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
+char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
+extern __printf(2, 0)
+const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);
+extern __scanf(2, 3)
+int sscanf(const char *, const char *, ...);
+extern __scanf(2, 0)
+int vsscanf(const char *, const char *, va_list);
+extern int oops_in_progress;		/* If set, an oops, panic(), BUG() or die() is in progress */
 enum lockdep_ok {
 	LOCKDEP_STILL_OK,
 	LOCKDEP_NOW_UNRELIABLE
 };
 extern void add_taint(unsigned flag, enum lockdep_ok);
 #define TAINT_CRAP			10
 #define TAINT_FIRMWARE_WORKAROUND	11
 #define TAINT_OOT_MODULE		12
 #define TAINT_UNSIGNED_MODULE		13
 #define TAINT_SOFTLOCKUP		14
+#define TAINT_LIVEPATCH			15
 extern const char hex_asc[];
 #define hex_asc_lo(x)	hex_asc[((x) & 0x0f)]
  * trace is not enough, but tracing must actually stop because things
  * like calling smp_processor_id() may crash the system.
+ *
  * Most likely, you want to use tracing_on/tracing_off.
  */
-#ifdef CONFIG_RING_BUFFER
-/* trace_off_permanent stops recording with no way to bring it back */
-void tracing_off_permanent(void);
-#else
-static inline void tracing_off_permanent(void) { }
-#endif
 enum ftrace_dump_mode {
 	DUMP_NONE,
 	DUMP_ALL,
 		__ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs);	\
 	} else								\
 		__ftrace_vprintk(_THIS_IP_, fmt, vargs);		\
 } while (0)
-extern int
+extern __printf(2, 0) int
 __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
-extern int
+extern __printf(2, 0) int
 __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 static inline __printf(1, 2)
 int trace_printk(const char *fmt, ...)
+{
 	return 0;
+}
-static inline int
+static __printf(1, 0) inline int
 ftrace_vprintk(const char *fmt, va_list ap)
+{
 	return 0;
+}
 static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 /* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
-#define VERIFY_OCTAL_PERMISSIONS(perms)					\
+#define VERIFY_OCTAL_PERMISSIONS(perms)						\
-	(BUILD_BUG_ON_ZERO((perms) < 0) +				\
+	(BUILD_BUG_ON_ZERO((perms) < 0) +					\
-	 BUILD_BUG_ON_ZERO((perms) > 0777) +				\
+	 BUILD_BUG_ON_ZERO((perms) > 0777) +					\
-	 /* User perms >= group perms >= other perms */			\
+	 /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */		\
-	 BUILD_BUG_ON_ZERO(((perms) >> 6) < (((perms) >> 3) & 7)) +	\
+	 BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +	\
+	 BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +		\
+	 /* USER_WRITABLE >= GROUP_WRITABLE */					\
-	 BUILD_BUG_ON_ZERO((((perms) >> 3) & 7) < ((perms) & 7)) +	\
+	 BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +	\
-	 /* Other writable?  Generally considered a bad idea. */	\
+	 /* OTHER_WRITABLE?  Generally considered a bad idea. */		\
-	 BUILD_BUG_ON_ZERO((perms) & 2) +				\
+	 BUILD_BUG_ON_ZERO((perms) & 2) +					\
 	 (perms))
 };
 struct vm_area_struct {};
-struct address_space {};
-struct device
-{
-    struct device   *parent;
-    void            *driver_data;
-};
-static inline void dev_set_drvdata(struct device *dev, void *data)
-{
-    dev->driver_data = data;
-}
-static inline void *dev_get_drvdata(struct device *dev)
-{
-    return dev->driver_data;
 struct address_space {};
 #define pci_unmap_page(dev, dma_address, size, direction)
-#define IS_ENABLED(a)  0
-#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define IS_ENABLED(a)  0
     __builtin_memcpy((void __force *)to, from, n);
     return 0;
-}
 struct seq_file;
 void *kmap(struct page *page);
 void *kmap_atomic(struct page *page);
 #define __init
 #define CONFIG_PAGE_OFFSET 0

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/kernel.h – Rev 5272 → 6082