uml: fix !NO_HZ busy-loop

	return timeval_to_ns(&tv);

}

#ifdef UML_CONFIG_NO_HZ

static int after_sleep_interval(struct timespec *ts)

{

}

#else

static inline long long timespec_to_us(const struct timespec *ts)

{

	return ((long long) ts->tv_sec * UM_USEC_PER_SEC) +

		ts->tv_nsec / UM_NSEC_PER_USEC;

}

static int after_sleep_interval(struct timespec *ts)

{

	int usec = UM_USEC_PER_SEC / UM_HZ;

	long long start_usecs = timespec_to_us(ts);

	struct timeval tv;

	struct itimerval interval;

	/*

	 * It seems that rounding can increase the value returned from

	 * setitimer to larger than the one passed in.  Over time,

	 * this will cause the remaining time to be greater than the

	 * tick interval.  If this happens, then just reduce the first

	 * tick to the interval value.

	 */

	if (start_usecs > usec)

		start_usecs = usec;

	tv = ((struct timeval) { .tv_sec  = start_usecs / UM_USEC_PER_SEC,

				 .tv_usec = start_usecs % UM_USEC_PER_SEC });

	interval = ((struct itimerval) { { 0, usec }, tv });

	if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1)

		return -errno;

	return 0;

}

#endif

extern void alarm_handler(int sig, struct sigcontext *sc);

void idle_sleep(unsigned long long nsecs)

{

	struct timespec ts = { .tv_sec	= nsecs / UM_NSEC_PER_SEC,

			       .tv_nsec = nsecs % UM_NSEC_PER_SEC };

	struct timespec ts;

	/*

	 * nsecs can come in as zero, in which case, this starts a

	 * busy loop.  To prevent this, reset nsecs to the tick

	 * interval if it is zero.

	 */

	if (nsecs == 0)

		nsecs = UM_NSEC_PER_SEC / UM_HZ;

	ts = ((struct timespec) { .tv_sec	= nsecs / UM_NSEC_PER_SEC,

				  .tv_nsec	= nsecs % UM_NSEC_PER_SEC });

	if (nanosleep(&ts, &ts) == 0)

		alarm_handler(SIGVTALRM, NULL);

	after_sleep_interval(&ts);

}