lkml.org 
[lkml]   [2009]   [Dec]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 08/14] kernel.h: Group math and limits functions, indent function args
    Date
    Use a bit more standardized statement expression format

    Signed-off-by:; Joe Perches <joe@perches.com>
    ---
    include/linux/kernel.h | 72 +++++++++++++++++++++++++++++------------------
    1 files changed, 44 insertions(+), 28 deletions(-)

    diff --git a/include/linux/kernel.h b/include/linux/kernel.h
    index 1764d2d..97c80c7 100644
    --- a/include/linux/kernel.h
    +++ b/include/linux/kernel.h
    @@ -115,12 +115,6 @@ void __might_sleep(char *file, int line, int preempt_offset);

    #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)

    -#define abs(x) \
    -({ \
    - long __x = (x); \
    - (__x < 0) ? -__x : __x; \
    -})
    -
    #ifdef CONFIG_PROVE_LOCKING
    void might_fault(void);
    #else
    @@ -240,21 +234,36 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
    }

    /*
    + * stdlib - limits and maths
    + */
    +#define abs(x) \
    +({ \
    + long __x = (x); \
    + (__x < 0) ? -__x : __x; \
    +})
    +
    +unsigned long int_sqrt(unsigned long);
    +
    +/*
    * min()/max()/clamp() macros that also do
    * strict type-checking.. See the
    * "unnecessary" pointer comparison.
    */
    -#define min(x, y) ({ \
    +#define min(x, y) \
    +({ \
    typeof(x) _min1 = (x); \
    typeof(y) _min2 = (y); \
    (void) (&_min1 == &_min2); \
    - _min1 < _min2 ? _min1 : _min2; })
    + _min1 < _min2 ? _min1 : _min2; \
    +})

    -#define max(x, y) ({ \
    +#define max(x, y) \
    +({ \
    typeof(x) _max1 = (x); \
    typeof(y) _max2 = (y); \
    (void) (&_max1 == &_max2); \
    - _max1 > _max2 ? _max1 : _max2; })
    + _max1 > _max2 ? _max1 : _max2; \
    +})

    /**
    * clamp - return a value clamped to a given range with strict typechecking
    @@ -265,14 +274,16 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
    * This macro does strict typechecking of min/max to make sure they are of the
    * same type as val. See the unnecessary pointer comparisons.
    */
    -#define clamp(val, min, max) ({ \
    +#define clamp(val, min, max) \
    +({ \
    typeof(val) __val = (val); \
    typeof(min) __min = (min); \
    typeof(max) __max = (max); \
    (void) (&__val == &__min); \
    (void) (&__val == &__max); \
    __val = __val < __min ? __min : __val; \
    - __val > __max ? __max : __val; })
    + __val > __max ? __max : __val; \
    +})

    /*
    * ..and if you can't take the strict
    @@ -280,15 +291,19 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
    *
    * Or not use min/max/clamp at all, of course.
    */
    -#define min_t(type, x, y) ({ \
    +#define min_t(type, x, y) \
    +({ \
    type __min1 = (x); \
    type __min2 = (y); \
    - __min1 < __min2 ? __min1 : __min2; })
    + __min1 < __min2 ? __min1 : __min2; \
    +})

    -#define max_t(type, x, y) ({ \
    +#define max_t(type, x, y) \
    +({ \
    type __max1 = (x); \
    type __max2 = (y); \
    - __max1 > __max2 ? __max1 : __max2; })
    + __max1 > __max2 ? __max1 : __max2; \
    +})

    /**
    * clamp_t - return a value clamped to a given range using a given type
    @@ -300,12 +315,14 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
    * This macro does no typechecking and uses temporary variables of type
    * 'type' to make all the comparisons.
    */
    -#define clamp_t(type, val, min, max) ({ \
    +#define clamp_t(type, val, min, max) \
    +({ \
    type __val = (val); \
    type __min = (min); \
    type __max = (max); \
    __val = __val < __min ? __min : __val; \
    - __val > __max ? __max : __val; })
    + __val > __max ? __max : __val; \
    +})

    /**
    * clamp_val - return a value clamped to a given range using val's type
    @@ -318,13 +335,14 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
    * type and min and max are literals that will otherwise be assigned a signed
    * integer type.
    */
    -#define clamp_val(val, min, max) ({ \
    +#define clamp_val(val, min, max) \
    +({ \
    typeof(val) __val = (val); \
    typeof(val) __min = (min); \
    typeof(val) __max = (max); \
    __val = __val < __min ? __min : __val; \
    - __val > __max ? __max : __val; })
    -
    + __val > __max ? __max : __val; \
    +})

    /*
    * swap - swap value of @a and @b
    @@ -458,8 +476,6 @@ extern void printk_tick(void);
    extern void asmlinkage __attribute__((format(printf, 1, 2)))
    early_printk(const char *fmt, ...);

    -unsigned long int_sqrt(unsigned long);
    -
    static inline void console_silent(void)
    {
    console_loglevel = 0;
    @@ -485,13 +501,13 @@ enum {
    DUMP_PREFIX_OFFSET
    };
    extern void hex_dump_to_buffer(const void *buf, size_t len,
    - int rowsize, int groupsize,
    - char *linebuf, size_t linebuflen, bool ascii);
    + int rowsize, int groupsize,
    + char *linebuf, size_t linebuflen, bool ascii);
    extern void print_hex_dump(const char *level, const char *prefix_str,
    - int prefix_type, int rowsize, int groupsize,
    - const void *buf, size_t len, bool ascii);
    + int prefix_type, int rowsize, int groupsize,
    + const void *buf, size_t len, bool ascii);
    extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
    - const void *buf, size_t len);
    + const void *buf, size_t len);


    #ifndef pr_fmt
    --
    1.6.6.rc0.57.gad7a


    \
     
     \ /
      Last update: 2009-12-16 14:05    [W:0.056 / U:1.568 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site