Cleanup Fucking hrtimer

Author: UEFI-code

kernel/time/alarmtimer.c

@@ -503,37 +503,6 @@ EXPORT_SYMBOL_GPL(alarm_forward_now);
 
 #ifdef CONFIG_POSIX_TIMERS
 
-static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
-{
-	struct alarm_base *base;
-	unsigned long flags;
-	ktime_t delta;
-
-	switch(type) {
-	case ALARM_REALTIME:
-		base = &alarm_bases[ALARM_REALTIME];
-		type = ALARM_REALTIME_FREEZER;
-		break;
-	case ALARM_BOOTTIME:
-		base = &alarm_bases[ALARM_BOOTTIME];
-		type = ALARM_BOOTTIME_FREEZER;
-		break;
-	default:
-		WARN_ONCE(1, "Invalid alarm type: %d\n", type);
-		return;
-	}
-
-	delta = ktime_sub(absexp, base->get_ktime());
-
-	spin_lock_irqsave(&freezer_delta_lock, flags);
-	if (!freezer_delta || (delta < freezer_delta)) {
-		freezer_delta = delta;
-		freezer_expires = absexp;
-		freezer_alarmtype = type;
-	}
-	spin_unlock_irqrestore(&freezer_delta_lock, flags);
-}
-
 /**
  * clock2alarm - helper that converts from clockid to alarmtypes
  * @clockid: clockid.
@@ -767,41 +736,17 @@ static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
  *
  * Sets the alarm timer and sleeps until it is fired or interrupted.
  */
-static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
+static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t sleep_req,
 				enum alarmtimer_type type)
 {
-	struct restart_block *restart;
-	alarm->data = (void *)current;
-	do {
-		set_current_state(TASK_INTERRUPTIBLE);
-		alarm_start(alarm, absexp);
-		if (likely(alarm->data))
-			schedule();
-
-		alarm_cancel(alarm);
-	} while (alarm->data && !signal_pending(current));
-
-	__set_current_state(TASK_RUNNING);
-
-	destroy_hrtimer_on_stack(&alarm->timer);
-
-	if (!alarm->data)
-		return 0;
-
-	if (freezing(current))
-		alarmtimer_freezerset(absexp, type);
-	restart = &current->restart_block;
-	if (restart->nanosleep.type != TT_NONE) {
-		struct timespec64 rmt;
-		ktime_t rem;
-
-		rem = ktime_sub(absexp, alarm_bases[type].get_ktime());
-
-		if (rem <= 0)
-			return 0;
-		rmt = ktime_to_timespec64(rem);
-
-		return nanosleep_copyout(restart, &rmt);
+	ktime_t start_time = ktime_get();
+	while(!signal_pending(current))
+	{
+		asm volatile("hlt");
+		if((ktime_get() - start_time) >= sleep_req)
+		{
+			return 0; //終わり
+		}
 	}
 	return -ERESTART_RESTARTBLOCK;
 }

kernel/time/hrtimer.c

@@ -2016,106 +2016,6 @@ void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, clockid_t clock_id,
 }
 EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
 
-int nanosleep_copyout(struct restart_block *restart, struct timespec64 *ts)
-{
-	switch(restart->nanosleep.type) {
-#ifdef CONFIG_COMPAT_32BIT_TIME
-	case TT_COMPAT:
-		if (put_old_timespec32(ts, restart->nanosleep.compat_rmtp))
-			return -EFAULT;
-		break;
-#endif
-	case TT_NATIVE:
-		if (put_timespec64(ts, restart->nanosleep.rmtp))
-			return -EFAULT;
-		break;
-	default:
-		BUG();
-	}
-	return -ERESTART_RESTARTBLOCK;
-}
-
-static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
-{
-	struct restart_block *restart;
-
-	do {
-		set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
-		hrtimer_sleeper_start_expires(t, mode);
-
-		if (likely(t->task))
-			schedule();
-
-		hrtimer_cancel(&t->timer);
-		mode = HRTIMER_MODE_ABS;
-
-	} while (t->task && !signal_pending(current));
-
-	__set_current_state(TASK_RUNNING);
-
-	if (!t->task)
-		return 0;
-
-	restart = &current->restart_block;
-	if (restart->nanosleep.type != TT_NONE) {
-		ktime_t rem = hrtimer_expires_remaining(&t->timer);
-		struct timespec64 rmt;
-
-		if (rem <= 0)
-			return 0;
-		rmt = ktime_to_timespec64(rem);
-
-		return nanosleep_copyout(restart, &rmt);
-	}
-	return -ERESTART_RESTARTBLOCK;
-}
-
-static long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
-{
-	struct hrtimer_sleeper t;
-	int ret;
-
-	hrtimer_init_sleeper_on_stack(&t, restart->nanosleep.clockid,
-				      HRTIMER_MODE_ABS);
-	hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
-	ret = do_nanosleep(&t, HRTIMER_MODE_ABS);
-	destroy_hrtimer_on_stack(&t.timer);
-	return ret;
-}
-
-long hrtimer_nanosleep(ktime_t rqtp, const enum hrtimer_mode mode,
-		       const clockid_t clockid)
-{
-	struct restart_block *restart;
-	struct hrtimer_sleeper t;
-	int ret = 0;
-	u64 slack;
-
-	slack = current->timer_slack_ns;
-	if (rt_task(current))
-		slack = 0;
-
-	hrtimer_init_sleeper_on_stack(&t, clockid, mode);
-	hrtimer_set_expires_range_ns(&t.timer, rqtp, slack);
-	ret = do_nanosleep(&t, mode);
-	if (ret != -ERESTART_RESTARTBLOCK)
-		goto out;
-
-	/* Absolute timers do not update the rmtp value and restart: */
-	if (mode == HRTIMER_MODE_ABS) {
-		ret = -ERESTARTNOHAND;
-		goto out;
-	}
-
-	restart = &current->restart_block;
-	restart->nanosleep.clockid = t.timer.base->clockid;
-	restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
-	set_restart_fn(restart, hrtimer_nanosleep_restart);
-out:
-	destroy_hrtimer_on_stack(&t.timer);
-	return ret;
-}
-
 #ifdef CONFIG_64BIT
 
 SYSCALL_DEFINE2(nanosleep, struct __kernel_timespec __user *, rqtp,
@@ -2151,19 +2051,27 @@ SYSCALL_DEFINE2(nanosleep, struct __kernel_timespec __user *, rqtp,
 SYSCALL_DEFINE2(nanosleep_time32, struct old_timespec32 __user *, rqtp,
 		       struct old_timespec32 __user *, rmtp)
 {
-	struct timespec64 tu;
+	ktime_t start_time = ktime_get();
 
+	struct timespec64 tu;
 	if (get_old_timespec32(&tu, rqtp))
 		return -EFAULT;
-
 	if (!timespec64_valid(&tu))
 		return -EINVAL;
+	ktime_t sleep_req = tu.tv_sec * 1000000000ULL + tu.tv_nsec; // get 本物
+	
+	while(!signal_pending(current))
+	{
+		asm volatile("hlt");
+		if((ktime_get() - start_time) >= sleep_req)
+		{
+			return 0; //終わり
+		}
+	}
 
-	current->restart_block.fn = do_no_restart_syscall;
-	current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
-	current->restart_block.nanosleep.compat_rmtp = rmtp;
-	return hrtimer_nanosleep(timespec64_to_ktime(tu), HRTIMER_MODE_REL,
-				 CLOCK_MONOTONIC);
+	struct old_timespec32 shit_buf = { .tv_sec = 0, .tv_nsec = sleep_req - (ktime_get() - start_time) };
+	copy_to_user(rmtp, &shit_buf, sizeof(shit_buf)); // Fucking Call-Convention!
+	return -ERESTART_RESTARTBLOCK;
 }
 #endif
 

kernel/time/posix-cpu-timers.c

@@ -1501,90 +1501,17 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clkid,
 static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
 			    const struct timespec64 *rqtp)
 {
-	struct itimerspec64 it;
-	struct k_itimer timer;
-	u64 expires;
-	int error;
-
-	/*
-	 * Set up a temporary timer and then wait for it to go off.
-	 */
-	memset(&timer, 0, sizeof timer);
-	spin_lock_init(&timer.it_lock);
-	timer.it_clock = which_clock;
-	timer.it_overrun = -1;
-	error = posix_cpu_timer_create(&timer);
-	timer.it_process = current;
-
-	if (!error) {
-		static struct itimerspec64 zero_it;
-		struct restart_block *restart;
-
-		memset(&it, 0, sizeof(it));
-		it.it_value = *rqtp;
-
-		spin_lock_irq(&timer.it_lock);
-		error = posix_cpu_timer_set(&timer, flags, &it, NULL);
-		if (error) {
-			spin_unlock_irq(&timer.it_lock);
-			return error;
-		}
-
-		while (!signal_pending(current)) {
-			if (!cpu_timer_getexpires(&timer.it.cpu)) {
-				/*
-				 * Our timer fired and was reset, below
-				 * deletion can not fail.
-				 */
-				posix_cpu_timer_del(&timer);
-				spin_unlock_irq(&timer.it_lock);
-				return 0;
-			}
-
-			/*
-			 * Block until cpu_timer_fire (or a signal) wakes us.
-			 */
-			__set_current_state(TASK_INTERRUPTIBLE);
-			spin_unlock_irq(&timer.it_lock);
-			schedule();
-			spin_lock_irq(&timer.it_lock);
-		}
-
-		/*
-		 * We were interrupted by a signal.
-		 */
-		expires = cpu_timer_getexpires(&timer.it.cpu);
-		error = posix_cpu_timer_set(&timer, 0, &zero_it, &it);
-		if (!error) {
-			/* Timer is now unarmed, deletion can not fail. */
-			posix_cpu_timer_del(&timer);
-		} else {
-			while (error == TIMER_RETRY) {
-				posix_cpu_timer_wait_running_nsleep(&timer);
-				error = posix_cpu_timer_del(&timer);
-			}
+	ktime_t start_time = ktime_get();
+	ktime_t sleep_req = rqtp->tv_sec * 1000000000ULL + rqtp->tv_nsec;
+	while(!signal_pending(current))
+	{
+		asm volatile("hlt");
+		if((ktime_get() - start_time) >= sleep_req)
+		{
+			return 0; //終わり
 		}
-
-		spin_unlock_irq(&timer.it_lock);
-
-		if ((it.it_value.tv_sec | it.it_value.tv_nsec) == 0) {
-			/*
-			 * It actually did fire already.
-			 */
-			return 0;
-		}
-
-		error = -ERESTART_RESTARTBLOCK;
-		/*
-		 * Report back to the user the time still remaining.
-		 */
-		restart = &current->restart_block;
-		restart->nanosleep.expires = expires;
-		if (restart->nanosleep.type != TT_NONE)
-			error = nanosleep_copyout(restart, &it.it_value);
 	}
-
-	return error;
+	return -1;
 }
 
 static long posix_cpu_nsleep_restart(struct restart_block *restart_block);

kernel/time/posix-timers.c

@@ -1345,11 +1345,17 @@ SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
 static int common_nsleep(const clockid_t which_clock, int flags,
 			 const struct timespec64 *rqtp)
 {
-	ktime_t texp = timespec64_to_ktime(*rqtp);
-
-	return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
-				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
-				 which_clock);
+	ktime_t start_time = ktime_get();
+	ktime_t sleep_req = rqtp->tv_sec * 1000000000ULL + rqtp->tv_nsec;
+	while(!signal_pending(current))
+	{
+		asm volatile("hlt");
+		if((ktime_get() - start_time) >= sleep_req)
+		{
+			return 0; //終わり
+		}
+	}
+	return -1;
 }
 
 /*
@@ -1360,14 +1366,19 @@ static int common_nsleep(const clockid_t which_clock, int flags,
 static int common_nsleep_timens(const clockid_t which_clock, int flags,
 				const struct timespec64 *rqtp)
 {
-	ktime_t texp = timespec64_to_ktime(*rqtp);
-
+	ktime_t start_time = ktime_get();
+	ktime_t sleep_req = rqtp->tv_sec * 1000000000ULL + rqtp->tv_nsec;
 	if (flags & TIMER_ABSTIME)
-		texp = timens_ktime_to_host(which_clock, texp);
-
-	return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
-				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
-				 which_clock);
+		sleep_req = timens_ktime_to_host(which_clock, sleep_req);
+	while(!signal_pending(current))
+	{
+		asm volatile("hlt");
+		if((ktime_get() - start_time) >= sleep_req)
+		{
+			return 0; //終わり
+		}
+	}
+	return -1;
 }
 
 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,