Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 64861634 authored by Martin Schwidefsky's avatar Martin Schwidefsky
Browse files

[S390] cputime: add sparse checking and cleanup 



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: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent 55b02d2f

arch/ia64/include/asm/cputime.h

+32 −37
Original line number Diff line number Diff line
@@ -26,59 +26,51 @@ 
#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;

}



/*
@@ -86,25 +78,28 @@ static inline void cputime_to_timespec(const cputime_t ct, struct timespec *val) 
 */

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 */

arch/powerpc/include/asm/cputime.h

+27 −43
Original line number Diff line number Diff line
@@ -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__
@@ -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
@@ -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) /

		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 */
@@ -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)
@@ -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 */
@@ -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);

}



/*
@@ -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 */
@@ -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;

}



/*
@@ -157,12 +141,12 @@ 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);

}



/*
@@ -170,7 +154,7 @@ static inline cputime_t secs_to_cputime(const unsigned long sec) 
 */

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);
@@ -182,11 +166,11 @@ 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);

}



/*
@@ -194,7 +178,7 @@ static inline cputime_t timespec_to_cputime(const struct timespec *p) 
 */

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);
@@ -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);

}



/*
@@ -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 */
@@ -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))

arch/s390/include/asm/cputime.h

+63 −77
Original line number Diff line number Diff line
@@ -16,114 +16,98 @@ 


/* We want to use full resolution of the CPU timer: 2**-12 micro-seconds. */



typedef unsigned long long cputime_t;

typedef unsigned long long cputime64_t;

typedef unsigned long long __nocast cputime_t;

typedef unsigned long long __nocast cputime64_t;



#ifndef __s390x__



static inline unsigned int

__div(unsigned long long n, unsigned int base)

static inline unsigned long __div(unsigned long long n, unsigned long base)

{

#ifndef __s390x__

	register_pair rp;



	rp.pair = n >> 1;

	asm ("dr %0,%1" : "+d" (rp) : "d" (base >> 1));

	return rp.subreg.odd;

#else /* __s390x__ */

	return n / base;

#endif /* __s390x__ */

}



#else /* __s390x__ */

#define cputime_one_jiffy		jiffies_to_cputime(1)



static inline unsigned int

__div(unsigned long long n, unsigned int base)

/*

 * Convert cputime to jiffies and back.

 */

static inline unsigned long cputime_to_jiffies(const cputime_t cputime)

{

	return n / base;

	return __div((__force unsigned long long) cputime, 4096000000ULL / HZ);

}



#endif /* __s390x__ */

static inline cputime_t jiffies_to_cputime(const unsigned int jif)

{

	return (__force cputime_t)(jif * (4096000000ULL / HZ));

}



#define cputime_zero			(0ULL)

#define cputime_one_jiffy		jiffies_to_cputime(1)

#define cputime_max			((~0UL >> 1) - 1)

#define cputime_add(__a, __b)		((__a) +  (__b))

#define cputime_sub(__a, __b)		((__a) -  (__b))

#define cputime_div(__a, __n) ({		\

	unsigned long long __div = (__a);	\

	do_div(__div,__n);			\

	__div;					\

})

#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 cputime_to_jiffies(__ct)	(__div((__ct), 4096000000ULL / HZ))

#define cputime_to_scaled(__ct)		(__ct)

#define jiffies_to_cputime(__hz)	((cputime_t)(__hz) * (4096000000ULL / HZ))



#define cputime64_zero			(0ULL)

#define cputime64_add(__a, __b)		((__a) + (__b))

#define cputime_to_cputime64(__ct)	(__ct)



static inline u64

cputime64_to_jiffies64(cputime64_t cputime)

{

	do_div(cputime, 4096000000ULL / HZ);

	return cputime;

static inline u64 cputime64_to_jiffies64(cputime64_t cputime)

{

	unsigned long long jif = (__force unsigned long long) cputime;

	do_div(jif, 4096000000ULL / HZ);

	return jif;

}



static inline cputime64_t jiffies64_to_cputime64(const u64 jif)

{

	return (__force cputime64_t)(jif * (4096000000ULL / HZ));

}



/*

 * Convert cputime to microseconds and back.

 */

static inline unsigned int

cputime_to_usecs(const cputime_t cputime)

static inline unsigned int cputime_to_usecs(const cputime_t cputime)

{

	return cputime_div(cputime, 4096);

	return (__force unsigned long long) cputime >> 12;

}



static inline cputime_t

usecs_to_cputime(const unsigned int m)

static inline cputime_t usecs_to_cputime(const unsigned int m)

{

	return (cputime_t) m * 4096;

	return (__force cputime_t)(m * 4096ULL);

}



/*

 * Convert cputime to milliseconds and back.

 */

static inline unsigned int

cputime_to_secs(const cputime_t cputime)

static inline unsigned int cputime_to_secs(const cputime_t cputime)

{

	return __div(cputime, 2048000000) >> 1;

	return __div((__force unsigned long long) cputime, 2048000000) >> 1;

}



static inline cputime_t

secs_to_cputime(const unsigned int s)

static inline cputime_t secs_to_cputime(const unsigned int s)

{

	return (cputime_t) s * 4096000000ULL;

	return (__force cputime_t)(s * 4096000000ULL);

}



/*

 * Convert cputime to timespec and back.

 */

static inline cputime_t

timespec_to_cputime(const struct timespec *value)

static inline cputime_t timespec_to_cputime(const struct timespec *value)

{

	return value->tv_nsec * 4096 / 1000 + (u64) value->tv_sec * 4096000000ULL;

	unsigned long long ret = value->tv_sec * 4096000000ULL;

	return (__force cputime_t)(ret + value->tv_nsec * 4096 / 1000);

}



static inline void

cputime_to_timespec(const cputime_t cputime, struct timespec *value)

static inline void cputime_to_timespec(const cputime_t cputime,

				       struct timespec *value)

{

	unsigned long long __cputime = (__force unsigned long long) cputime;

#ifndef __s390x__

	register_pair rp;



	rp.pair = cputime >> 1;

	rp.pair = __cputime >> 1;

	asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));

	value->tv_nsec = rp.subreg.even * 1000 / 4096;

	value->tv_sec = rp.subreg.odd;

#else

	value->tv_nsec = (cputime % 4096000000ULL) * 1000 / 4096;

	value->tv_sec = cputime / 4096000000ULL;

	value->tv_nsec = (__cputime % 4096000000ULL) * 1000 / 4096;

	value->tv_sec = __cputime / 4096000000ULL;

#endif

}
@@ -132,50 +116,52 @@ cputime_to_timespec(const cputime_t cputime, struct timespec *value) 
 * Since cputime and timeval have the same resolution (microseconds)

 * this is easy.

 */

static inline cputime_t

timeval_to_cputime(const struct timeval *value)

static inline cputime_t timeval_to_cputime(const struct timeval *value)

{

	return value->tv_usec * 4096 + (u64) value->tv_sec * 4096000000ULL;

	unsigned long long ret = value->tv_sec * 4096000000ULL;

	return (__force cputime_t)(ret + value->tv_usec * 4096ULL);

}



static inline void

cputime_to_timeval(const cputime_t cputime, struct timeval *value)

static inline void cputime_to_timeval(const cputime_t cputime,

				      struct timeval *value)

{

	unsigned long long __cputime = (__force unsigned long long) cputime;

#ifndef __s390x__

	register_pair rp;



	rp.pair = cputime >> 1;

	rp.pair = __cputime >> 1;

	asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));

	value->tv_usec = rp.subreg.even / 4096;

	value->tv_sec = rp.subreg.odd;

#else

	value->tv_usec = (cputime % 4096000000ULL) / 4096;

	value->tv_sec = cputime / 4096000000ULL;

	value->tv_usec = (__cputime % 4096000000ULL) / 4096;

	value->tv_sec = __cputime / 4096000000ULL;

#endif

}



/*

 * Convert cputime to clock and back.

 */

static inline clock_t

cputime_to_clock_t(cputime_t cputime)

static inline clock_t cputime_to_clock_t(cputime_t cputime)

{

	return cputime_div(cputime, 4096000000ULL / USER_HZ);

	unsigned long long clock = (__force unsigned long long) cputime;

	do_div(clock, 4096000000ULL / USER_HZ);

	return clock;

}



static inline cputime_t

clock_t_to_cputime(unsigned long x)

static inline cputime_t clock_t_to_cputime(unsigned long x)

{

	return (cputime_t) x * (4096000000ULL / USER_HZ);

	return (__force cputime_t)(x * (4096000000ULL / USER_HZ));

}



/*

 * Convert cputime64 to clock.

 */

static inline clock_t

cputime64_to_clock_t(cputime64_t cputime)

static inline clock_t cputime64_to_clock_t(cputime64_t cputime)

{

       return cputime_div(cputime, 4096000000ULL / USER_HZ);

	unsigned long long clock = (__force unsigned long long) cputime;

	do_div(clock, 4096000000ULL / USER_HZ);

	return clock;

}



struct s390_idle_data {

drivers/cpufreq/cpufreq_conservative.c

+14 −15
Original line number Diff line number Diff line
@@ -103,15 +103,14 @@ static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu, 
	cputime64_t busy_time;



	cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());

	busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,

			kstat_cpu(cpu).cpustat.system);



	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);



	idle_time = cputime64_sub(cur_wall_time, busy_time);

	busy_time  = kstat_cpu(cpu).cpustat.user;

	busy_time += kstat_cpu(cpu).cpustat.system;

	busy_time += kstat_cpu(cpu).cpustat.irq;

	busy_time += kstat_cpu(cpu).cpustat.softirq;

	busy_time += kstat_cpu(cpu).cpustat.steal;

	busy_time += kstat_cpu(cpu).cpustat.nice;



	idle_time = cur_wall_time - busy_time;

	if (wall)

		*wall = (cputime64_t)jiffies_to_usecs(cur_wall_time);
@@ -353,20 +352,20 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) 


		cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);



		wall_time = (unsigned int) cputime64_sub(cur_wall_time,

				j_dbs_info->prev_cpu_wall);

		wall_time = (unsigned int)

			(cur_wall_time - j_dbs_info->prev_cpu_wall);

		j_dbs_info->prev_cpu_wall = cur_wall_time;



		idle_time = (unsigned int) cputime64_sub(cur_idle_time,

				j_dbs_info->prev_cpu_idle);

		idle_time = (unsigned int)

			(cur_idle_time - j_dbs_info->prev_cpu_idle);

		j_dbs_info->prev_cpu_idle = cur_idle_time;



		if (dbs_tuners_ins.ignore_nice) {

			cputime64_t cur_nice;

			unsigned long cur_nice_jiffies;



			cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice,

					 j_dbs_info->prev_cpu_nice);

			cur_nice = kstat_cpu(j).cpustat.nice -

					j_dbs_info->prev_cpu_nice;

			/*

			 * Assumption: nice time between sampling periods will

			 * be less than 2^32 jiffies for 32 bit sys

drivers/cpufreq/cpufreq_ondemand.c

+16 −17
Original line number Diff line number Diff line
@@ -127,15 +127,14 @@ static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu, 
	cputime64_t busy_time;



	cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());

	busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,

			kstat_cpu(cpu).cpustat.system);



	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);

	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);



	idle_time = cputime64_sub(cur_wall_time, busy_time);

	busy_time  = kstat_cpu(cpu).cpustat.user;

	busy_time += kstat_cpu(cpu).cpustat.system;

	busy_time += kstat_cpu(cpu).cpustat.irq;

	busy_time += kstat_cpu(cpu).cpustat.softirq;

	busy_time += kstat_cpu(cpu).cpustat.steal;

	busy_time += kstat_cpu(cpu).cpustat.nice;



	idle_time = cur_wall_time - busy_time;

	if (wall)

		*wall = (cputime64_t)jiffies_to_usecs(cur_wall_time);
@@ -442,24 +441,24 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) 
		cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);

		cur_iowait_time = get_cpu_iowait_time(j, &cur_wall_time);



		wall_time = (unsigned int) cputime64_sub(cur_wall_time,

				j_dbs_info->prev_cpu_wall);

		wall_time = (unsigned int)

			(cur_wall_time - j_dbs_info->prev_cpu_wall);

		j_dbs_info->prev_cpu_wall = cur_wall_time;



		idle_time = (unsigned int) cputime64_sub(cur_idle_time,

				j_dbs_info->prev_cpu_idle);

		idle_time = (unsigned int)

			(cur_idle_time - j_dbs_info->prev_cpu_idle);

		j_dbs_info->prev_cpu_idle = cur_idle_time;



		iowait_time = (unsigned int) cputime64_sub(cur_iowait_time,

				j_dbs_info->prev_cpu_iowait);

		iowait_time = (unsigned int)

			(cur_iowait_time - j_dbs_info->prev_cpu_iowait);

		j_dbs_info->prev_cpu_iowait = cur_iowait_time;



		if (dbs_tuners_ins.ignore_nice) {

			cputime64_t cur_nice;

			unsigned long cur_nice_jiffies;



			cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice,

					 j_dbs_info->prev_cpu_nice);

			cur_nice = kstat_cpu(j).cpustat.nice -

					j_dbs_info->prev_cpu_nice;

			/*

			 * Assumption: nice time between sampling periods will

			 * be less than 2^32 jiffies for 32 bit sys