Commit 0db49b72 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

* 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (40 commits)
  sched/tracing: Add a new tracepoint for sleeptime
  sched: Disable scheduler warnings during oopses
  sched: Fix cgroup movement of waking process
  sched: Fix cgroup movement of newly created process
  sched: Fix cgroup movement of forking process
  sched: Remove cfs bandwidth period check in tg_set_cfs_period()
  sched: Fix load-balance lock-breaking
  sched: Replace all_pinned with a generic flags field
  sched: Only queue remote wakeups when crossing cache boundaries
  sched: Add missing rcu_dereference() around ->real_parent usage
  [S390] fix cputime overflow in uptime_proc_show
  [S390] cputime: add sparse checking and cleanup
  sched: Mark parent and real_parent as __rcu
  sched, nohz: Fix missing RCU read lock
  sched, nohz: Set the NOHZ_BALANCE_KICK flag for idle load balancer
  sched, nohz: Fix the idle cpu check in nohz_idle_balance
  sched: Use jump_labels for sched_feat
  sched/accounting: Fix parameter passing in task_group_account_field
  sched/accounting: Fix user/system tick double accounting
  sched/accounting: Re-use scheduler statistics for the root cgroup
  ...

Fix up conflicts in
 - arch/ia64/include/asm/cputime.h, include/asm-generic/cputime.h
	usecs_to_cputime64() vs the sparse cleanups
 - kernel/sched/fair.c, kernel/time/tick-sched.c
	scheduler changes in multiple branches
parents 35b740e4 1ac9bc69

arch/ia64/include/asm/cputime.h

+34 −38
Original line number Diff line number Diff line
@@ -26,60 +26,53 @@ 
#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 usecs_to_cputime64(__usecs)	usecs_to_cputime(__usecs)

#define cputime_to_usecs(__ct)		\

	((__force u64)(__ct) / NSEC_PER_USEC)

#define usecs_to_cputime(__usecs)	\

	(__force cputime_t)((__usecs) * NSEC_PER_USEC)

#define usecs_to_cputime64(__usecs)	\

	(__force cputime64_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;

}



/*
@@ -87,25 +80,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;

}



#define usecs_to_cputime64(us)		usecs_to_cputime(us)
@@ -159,12 +143,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);

}



/*
@@ -172,7 +156,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);
@@ -184,11 +168,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);

}



/*
@@ -196,7 +180,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);
@@ -208,11 +192,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);

}



/*
@@ -222,12 +206,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 */
@@ -238,8 +222,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/appldata/appldata_os.c

+8 −8
Original line number Diff line number Diff line
@@ -115,21 +115,21 @@ static void appldata_get_os_data(void *data) 
	j = 0;

	for_each_online_cpu(i) {

		os_data->os_cpu[j].per_cpu_user =

			cputime_to_jiffies(kstat_cpu(i).cpustat.user);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_USER]);

		os_data->os_cpu[j].per_cpu_nice =

			cputime_to_jiffies(kstat_cpu(i).cpustat.nice);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_NICE]);

		os_data->os_cpu[j].per_cpu_system =

			cputime_to_jiffies(kstat_cpu(i).cpustat.system);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]);

		os_data->os_cpu[j].per_cpu_idle =

			cputime_to_jiffies(kstat_cpu(i).cpustat.idle);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IDLE]);

		os_data->os_cpu[j].per_cpu_irq =

			cputime_to_jiffies(kstat_cpu(i).cpustat.irq);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]);

		os_data->os_cpu[j].per_cpu_softirq =

			cputime_to_jiffies(kstat_cpu(i).cpustat.softirq);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]);

		os_data->os_cpu[j].per_cpu_iowait =

			cputime_to_jiffies(kstat_cpu(i).cpustat.iowait);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IOWAIT]);

		os_data->os_cpu[j].per_cpu_steal =

			cputime_to_jiffies(kstat_cpu(i).cpustat.steal);

			cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_STEAL]);

		os_data->os_cpu[j].cpu_id = i;

		j++;

	}

arch/s390/include/asm/cputime.h

+63 −77
Original line number Diff line number Diff line
@@ -16,75 +16,60 @@ 


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

}



#define usecs_to_cputime64(m)		usecs_to_cputime(m)
@@ -92,40 +77,39 @@ usecs_to_cputime(const unsigned int m) 
/*

 * 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

}
@@ -134,50 +118,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 {

arch/x86/include/asm/i387.h

+1 −1
Original line number Diff line number Diff line
@@ -218,7 +218,7 @@ static inline void fpu_fxsave(struct fpu *fpu) 
#ifdef CONFIG_SMP

#define safe_address (__per_cpu_offset[0])

#else

#define safe_address (kstat_cpu(0).cpustat.user)

#define safe_address (__get_cpu_var(kernel_cpustat).cpustat[CPUTIME_USER])

#endif



/*

CRA Git | Maintained and supported by SUSTech CRA and CCSE