Skip to content

Commit

Permalink
[S390] cputime: add sparse checking and cleanup
Browse files Browse the repository at this point in the history 
Make cputime_t and cputime64_t nocast to enable sparse checking to
detect incorrect use of cputime. Drop the cputime macros for simple
scalar operations. The conversion macros are still needed.

Signed-off-by: Martin Schwidefsky <[email protected]>
  • Loading branch information
Martin Schwidefsky committed Dec 15, 2011
1 parent 55b02d2 commit 6486163
Show file tree
Hide file tree
Showing 23 changed files with 323 additions and 429 deletions.
69 changes: 32 additions & 37 deletions arch/ia64/include/asm/cputime.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,85 +26,80 @@
#include <linux/jiffies.h>
#include <asm/processor.h>

typedef u64 cputime_t;
typedef u64 cputime64_t;
typedef u64 __nocast cputime_t;
typedef u64 __nocast cputime64_t;

#define cputime_zero ((cputime_t)0)
#define cputime_one_jiffy jiffies_to_cputime(1)
#define cputime_max ((~((cputime_t)0) >> 1) - 1)
#define cputime_add(__a, __b) ((__a) + (__b))
#define cputime_sub(__a, __b) ((__a) - (__b))
#define cputime_div(__a, __n) ((__a) / (__n))
#define cputime_halve(__a) ((__a) >> 1)
#define cputime_eq(__a, __b) ((__a) == (__b))
#define cputime_gt(__a, __b) ((__a) > (__b))
#define cputime_ge(__a, __b) ((__a) >= (__b))
#define cputime_lt(__a, __b) ((__a) < (__b))
#define cputime_le(__a, __b) ((__a) <= (__b))

#define cputime64_zero ((cputime64_t)0)
#define cputime64_add(__a, __b) ((__a) + (__b))
#define cputime64_sub(__a, __b) ((__a) - (__b))
#define cputime_to_cputime64(__ct) (__ct)

/*
* Convert cputime <-> jiffies (HZ)
*/
#define cputime_to_jiffies(__ct) ((__ct) / (NSEC_PER_SEC / HZ))
#define jiffies_to_cputime(__jif) ((__jif) * (NSEC_PER_SEC / HZ))
#define cputime64_to_jiffies64(__ct) ((__ct) / (NSEC_PER_SEC / HZ))
#define jiffies64_to_cputime64(__jif) ((__jif) * (NSEC_PER_SEC / HZ))
#define cputime_to_jiffies(__ct) \
((__force u64)(__ct) / (NSEC_PER_SEC / HZ))
#define jiffies_to_cputime(__jif) \
(__force cputime_t)((__jif) * (NSEC_PER_SEC / HZ))
#define cputime64_to_jiffies64(__ct) \
((__force u64)(__ct) / (NSEC_PER_SEC / HZ))
#define jiffies64_to_cputime64(__jif) \
(__force cputime64_t)((__jif) * (NSEC_PER_SEC / HZ))

/*
* Convert cputime <-> microseconds
*/
#define cputime_to_usecs(__ct) ((__ct) / NSEC_PER_USEC)
#define usecs_to_cputime(__usecs) ((__usecs) * NSEC_PER_USEC)
#define cputime_to_usecs(__ct) \
((__force u64)(__ct) / NSEC_PER_USEC)
#define usecs_to_cputime(__usecs) \
(__force cputime_t)((__usecs) * NSEC_PER_USEC)

/*
* Convert cputime <-> seconds
*/
#define cputime_to_secs(__ct) ((__ct) / NSEC_PER_SEC)
#define secs_to_cputime(__secs) ((__secs) * NSEC_PER_SEC)
#define cputime_to_secs(__ct) \
((__force u64)(__ct) / NSEC_PER_SEC)
#define secs_to_cputime(__secs) \
(__force cputime_t)((__secs) * NSEC_PER_SEC)

/*
* Convert cputime <-> timespec (nsec)
*/
static inline cputime_t timespec_to_cputime(const struct timespec *val)
{
cputime_t ret = val->tv_sec * NSEC_PER_SEC;
return (ret + val->tv_nsec);
u64 ret = val->tv_sec * NSEC_PER_SEC + val->tv_nsec;
return (__force cputime_t) ret;
}
static inline void cputime_to_timespec(const cputime_t ct, struct timespec *val)
{
val->tv_sec = ct / NSEC_PER_SEC;
val->tv_nsec = ct % NSEC_PER_SEC;
val->tv_sec = (__force u64) ct / NSEC_PER_SEC;
val->tv_nsec = (__force u64) ct % NSEC_PER_SEC;
}

/*
* Convert cputime <-> timeval (msec)
*/
static inline cputime_t timeval_to_cputime(struct timeval *val)
{
cputime_t ret = val->tv_sec * NSEC_PER_SEC;
return (ret + val->tv_usec * NSEC_PER_USEC);
u64 ret = val->tv_sec * NSEC_PER_SEC + val->tv_usec * NSEC_PER_USEC;
return (__force cputime_t) ret;
}
static inline void cputime_to_timeval(const cputime_t ct, struct timeval *val)
{
val->tv_sec = ct / NSEC_PER_SEC;
val->tv_usec = (ct % NSEC_PER_SEC) / NSEC_PER_USEC;
val->tv_sec = (__force u64) ct / NSEC_PER_SEC;
val->tv_usec = ((__force u64) ct % NSEC_PER_SEC) / NSEC_PER_USEC;
}

/*
* Convert cputime <-> clock (USER_HZ)
*/
#define cputime_to_clock_t(__ct) ((__ct) / (NSEC_PER_SEC / USER_HZ))
#define clock_t_to_cputime(__x) ((__x) * (NSEC_PER_SEC / USER_HZ))
#define cputime_to_clock_t(__ct) \
((__force u64)(__ct) / (NSEC_PER_SEC / USER_HZ))
#define clock_t_to_cputime(__x) \
(__force cputime_t)((__x) * (NSEC_PER_SEC / USER_HZ))

/*
* Convert cputime64 to clock.
*/
#define cputime64_to_clock_t(__ct) cputime_to_clock_t((cputime_t)__ct)
#define cputime64_to_clock_t(__ct) \
cputime_to_clock_t((__force cputime_t)__ct)

#endif /* CONFIG_VIRT_CPU_ACCOUNTING */
#endif /* __IA64_CPUTIME_H */
70 changes: 27 additions & 43 deletions arch/powerpc/include/asm/cputime.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,25 +29,8 @@ static inline void setup_cputime_one_jiffy(void) { }
#include <asm/time.h>
#include <asm/param.h>

typedef u64 cputime_t;
typedef u64 cputime64_t;

#define cputime_zero ((cputime_t)0)
#define cputime_max ((~((cputime_t)0) >> 1) - 1)
#define cputime_add(__a, __b) ((__a) + (__b))
#define cputime_sub(__a, __b) ((__a) - (__b))
#define cputime_div(__a, __n) ((__a) / (__n))
#define cputime_halve(__a) ((__a) >> 1)
#define cputime_eq(__a, __b) ((__a) == (__b))
#define cputime_gt(__a, __b) ((__a) > (__b))
#define cputime_ge(__a, __b) ((__a) >= (__b))
#define cputime_lt(__a, __b) ((__a) < (__b))
#define cputime_le(__a, __b) ((__a) <= (__b))

#define cputime64_zero ((cputime64_t)0)
#define cputime64_add(__a, __b) ((__a) + (__b))
#define cputime64_sub(__a, __b) ((__a) - (__b))
#define cputime_to_cputime64(__ct) (__ct)
typedef u64 __nocast cputime_t;
typedef u64 __nocast cputime64_t;

#ifdef __KERNEL__

Expand All @@ -65,7 +48,7 @@ DECLARE_PER_CPU(unsigned long, cputime_scaled_last_delta);

static inline unsigned long cputime_to_jiffies(const cputime_t ct)
{
return mulhdu(ct, __cputime_jiffies_factor);
return mulhdu((__force u64) ct, __cputime_jiffies_factor);
}

/* Estimate the scaled cputime by scaling the real cputime based on
Expand All @@ -74,14 +57,15 @@ static inline cputime_t cputime_to_scaled(const cputime_t ct)
{
if (cpu_has_feature(CPU_FTR_SPURR) &&
__get_cpu_var(cputime_last_delta))
return ct * __get_cpu_var(cputime_scaled_last_delta) /
__get_cpu_var(cputime_last_delta);
return (__force u64) ct *
__get_cpu_var(cputime_scaled_last_delta) /
__get_cpu_var(cputime_last_delta);
return ct;
}

static inline cputime_t jiffies_to_cputime(const unsigned long jif)
{
cputime_t ct;
u64 ct;
unsigned long sec;

/* have to be a little careful about overflow */
Expand All @@ -93,7 +77,7 @@ static inline cputime_t jiffies_to_cputime(const unsigned long jif)
}
if (sec)
ct += (cputime_t) sec * tb_ticks_per_sec;
return ct;
return (__force cputime_t) ct;
}

static inline void setup_cputime_one_jiffy(void)
Expand All @@ -103,7 +87,7 @@ static inline void setup_cputime_one_jiffy(void)

static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
{
cputime_t ct;
u64 ct;
u64 sec;

/* have to be a little careful about overflow */
Expand All @@ -114,13 +98,13 @@ static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
do_div(ct, HZ);
}
if (sec)
ct += (cputime_t) sec * tb_ticks_per_sec;
return ct;
ct += (u64) sec * tb_ticks_per_sec;
return (__force cputime64_t) ct;
}

static inline u64 cputime64_to_jiffies64(const cputime_t ct)
{
return mulhdu(ct, __cputime_jiffies_factor);
return mulhdu((__force u64) ct, __cputime_jiffies_factor);
}

/*
Expand All @@ -130,12 +114,12 @@ extern u64 __cputime_msec_factor;

static inline unsigned long cputime_to_usecs(const cputime_t ct)
{
return mulhdu(ct, __cputime_msec_factor) * USEC_PER_MSEC;
return mulhdu((__force u64) ct, __cputime_msec_factor) * USEC_PER_MSEC;
}

static inline cputime_t usecs_to_cputime(const unsigned long us)
{
cputime_t ct;
u64 ct;
unsigned long sec;

/* have to be a little careful about overflow */
Expand All @@ -147,7 +131,7 @@ static inline cputime_t usecs_to_cputime(const unsigned long us)
}
if (sec)
ct += (cputime_t) sec * tb_ticks_per_sec;
return ct;
return (__force cputime_t) ct;
}

/*
Expand All @@ -157,20 +141,20 @@ extern u64 __cputime_sec_factor;

static inline unsigned long cputime_to_secs(const cputime_t ct)
{
return mulhdu(ct, __cputime_sec_factor);
return mulhdu((__force u64) ct, __cputime_sec_factor);
}

static inline cputime_t secs_to_cputime(const unsigned long sec)
{
return (cputime_t) sec * tb_ticks_per_sec;
return (__force cputime_t)((u64) sec * tb_ticks_per_sec);
}

/*
* Convert cputime <-> timespec
*/
static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)
{
u64 x = ct;
u64 x = (__force u64) ct;
unsigned int frac;

frac = do_div(x, tb_ticks_per_sec);
Expand All @@ -182,19 +166,19 @@ static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)

static inline cputime_t timespec_to_cputime(const struct timespec *p)
{
cputime_t ct;
u64 ct;

ct = (u64) p->tv_nsec * tb_ticks_per_sec;
do_div(ct, 1000000000);
return ct + (u64) p->tv_sec * tb_ticks_per_sec;
return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);
}

/*
* Convert cputime <-> timeval
*/
static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)
{
u64 x = ct;
u64 x = (__force u64) ct;
unsigned int frac;

frac = do_div(x, tb_ticks_per_sec);
Expand All @@ -206,11 +190,11 @@ static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)

static inline cputime_t timeval_to_cputime(const struct timeval *p)
{
cputime_t ct;
u64 ct;

ct = (u64) p->tv_usec * tb_ticks_per_sec;
do_div(ct, 1000000);
return ct + (u64) p->tv_sec * tb_ticks_per_sec;
return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);
}

/*
Expand All @@ -220,12 +204,12 @@ extern u64 __cputime_clockt_factor;

static inline unsigned long cputime_to_clock_t(const cputime_t ct)
{
return mulhdu(ct, __cputime_clockt_factor);
return mulhdu((__force u64) ct, __cputime_clockt_factor);
}

static inline cputime_t clock_t_to_cputime(const unsigned long clk)
{
cputime_t ct;
u64 ct;
unsigned long sec;

/* have to be a little careful about overflow */
Expand All @@ -236,8 +220,8 @@ static inline cputime_t clock_t_to_cputime(const unsigned long clk)
do_div(ct, USER_HZ);
}
if (sec)
ct += (cputime_t) sec * tb_ticks_per_sec;
return ct;
ct += (u64) sec * tb_ticks_per_sec;
return (__force cputime_t) ct;
}

#define cputime64_to_clock_t(ct) cputime_to_clock_t((cputime_t)(ct))
Expand Down
Loading

0 comments on commit 6486163

Please sign in to comment.