sched: Avoid cputime scaling overflow

}

/*

 * Perform (stime * rtime) / total with reduced chances

 * of multiplication overflows by using smaller factors

 * like quotient and remainders of divisions between

 * rtime and total.

 * Perform (stime * rtime) / total, but avoid multiplication overflow by

 * loosing precision when the numbers are big.

 */

static cputime_t scale_stime(u64 stime, u64 rtime, u64 total)

{

	u64 rem, res, scaled;

	u64 scaled;

	if (rtime >= total) {

		/*

		 * Scale up to rtime / total then add

		 * the remainder scaled to stime / total.

		 */

		res = div64_u64_rem(rtime, total, &rem);

		scaled = stime * res;

		scaled += div64_u64(stime * rem, total);

	} else {

		/*

		 * Same in reverse: scale down to total / rtime

		 * then substract that result scaled to

		 * to the remaining part.

		 */

		res = div64_u64_rem(total, rtime, &rem);

		scaled = div64_u64(stime, res);

		scaled -= div64_u64(scaled * rem, total);

	for (;;) {

		/* Make sure "rtime" is the bigger of stime/rtime */

		if (stime > rtime) {

			u64 tmp = rtime; rtime = stime; stime = tmp;

		}

		/* Make sure 'total' fits in 32 bits */

		if (total >> 32)

			goto drop_precision;

		/* Does rtime (and thus stime) fit in 32 bits? */

		if (!(rtime >> 32))

			break;

		/* Can we just balance rtime/stime rather than dropping bits? */

		if (stime >> 31)

			goto drop_precision;

		/* We can grow stime and shrink rtime and try to make them both fit */

		stime <<= 1;

		rtime >>= 1;

		continue;

drop_precision:

		/* We drop from rtime, it has more bits than stime */

		rtime >>= 1;

		total >>= 1;

	}

	/*

	 * Make sure gcc understands that this is a 32x32->64 multiply,

	 * followed by a 64/32->64 divide.

	 */

	scaled = div_u64((u64) (u32) stime * (u64) (u32) rtime, (u32)total);

	return (__force cputime_t) scaled;

}