hrtimer: convert kernel/* to the new hrtimer apis

In order to be able to do range hrtimers we need to use accessor functions to the "expire" member of the hrtimer struct. This patch converts kernel/* to these accessors. Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>

hrtimer: convert kernel/* to the new hrtimer apis
In order to be able to do range hrtimers we need to use accessor functions to the "expire" member of the hrtimer struct. This patch converts kernel/* to these accessors. Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
Arjan van de Ven
1 parent 23dd7bb09b
Showing 8 changed files with 47 additions and 52 deletions Side-by-side Diff
kernel/futex.c
kernel/hrtimer.c
kernel/posix-timers.c
kernel/rtmutex.c
kernel/sched.c
kernel/time/ntp.c
kernel/time/tick-sched.c
kernel/time/timer_list.c
@@ -1299,10 +1299,9 @@
 			hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC,
 						HRTIMER_MODE_ABS);
 			hrtimer_init_sleeper(&t, current);
-			t.timer.expires = *abs_time;
+			hrtimer_set_expires(&t.timer, *abs_time);
  
-			hrtimer_start(&t.timer, t.timer.expires,
-						HRTIMER_MODE_ABS);
+			hrtimer_start_expires(&t.timer, HRTIMER_MODE_ABS);
 			if (!hrtimer_active(&t.timer))
 				t.task = NULL;
  
@@ -1404,7 +1403,7 @@
 		hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,
 				      HRTIMER_MODE_ABS);
 		hrtimer_init_sleeper(to, current);
-		to->timer.expires = *time;
+		hrtimer_set_expires(&to->timer, *time);
 	}
  
 	q.pi_state = NULL;
@@ -517,7 +517,7 @@
 		if (!base->first)
 			continue;
 		timer = rb_entry(base->first, struct hrtimer, node);
-		expires = ktime_sub(timer->expires, base->offset);
+		expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
 		if (expires.tv64 < cpu_base->expires_next.tv64)
 			cpu_base->expires_next = expires;
 	}
  
@@ -539,10 +539,10 @@
 			     struct hrtimer_clock_base *base)
 {
 	ktime_t *expires_next = &__get_cpu_var(hrtimer_bases).expires_next;
-	ktime_t expires = ktime_sub(timer->expires, base->offset);
+	ktime_t expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
 	int res;
  
-	WARN_ON_ONCE(timer->expires.tv64 < 0);
+	WARN_ON_ONCE(hrtimer_get_expires_tv64(timer) < 0);
  
 	/*
 	 * When the callback is running, we do not reprogram the clock event
@@ -794,7 +794,7 @@
 	u64 orun = 1;
 	ktime_t delta;
  
-	delta = ktime_sub(now, timer->expires);
+	delta = ktime_sub(now, hrtimer_get_expires(timer));
  
 	if (delta.tv64 < 0)
 		return 0;
@@ -806,8 +806,8 @@
 		s64 incr = ktime_to_ns(interval);
  
 		orun = ktime_divns(delta, incr);
-		timer->expires = ktime_add_ns(timer->expires, incr * orun);
-		if (timer->expires.tv64 > now.tv64)
+		hrtimer_add_expires_ns(timer, incr * orun);
+		if (hrtimer_get_expires_tv64(timer) > now.tv64)
 			return orun;
 		/*
 		 * This (and the ktime_add() below) is the
@@ -815,7 +815,7 @@
 		 */
 		orun++;
 	}
-	timer->expires = ktime_add_safe(timer->expires, interval);
+	hrtimer_add_expires(timer, interval);
  
 	return orun;
 }
@@ -847,7 +847,8 @@
 		 * We dont care about collisions. Nodes with
 		 * the same expiry time stay together.
 		 */
-		if (timer->expires.tv64 < entry->expires.tv64) {
+		if (hrtimer_get_expires_tv64(timer) <
+				hrtimer_get_expires_tv64(entry)) {
 			link = &(*link)->rb_left;
 		} else {
 			link = &(*link)->rb_right;
@@ -982,7 +983,7 @@
 #endif
 	}
  
-	timer->expires = tim;
+	hrtimer_set_expires(timer, tim);
  
 	timer_stats_hrtimer_set_start_info(timer);
  
@@ -1076,7 +1077,7 @@
 	ktime_t rem;
  
 	base = lock_hrtimer_base(timer, &flags);
-	rem = ktime_sub(timer->expires, base->get_time());
+	rem = hrtimer_expires_remaining(timer);
 	unlock_hrtimer_base(timer, &flags);
  
 	return rem;
@@ -1108,7 +1109,7 @@
 				continue;
  
 			timer = rb_entry(base->first, struct hrtimer, node);
-			delta.tv64 = timer->expires.tv64;
+			delta.tv64 = hrtimer_get_expires_tv64(timer);
 			delta = ktime_sub(delta, base->get_time());
 			if (delta.tv64 < mindelta.tv64)
 				mindelta.tv64 = delta.tv64;
  
@@ -1308,10 +1309,10 @@
  
 			timer = rb_entry(node, struct hrtimer, node);
  
-			if (basenow.tv64 < timer->expires.tv64) {
+			if (basenow.tv64 < hrtimer_get_expires_tv64(timer)) {
 				ktime_t expires;
  
-				expires = ktime_sub(timer->expires,
+				expires = ktime_sub(hrtimer_get_expires(timer),
 						    base->offset);
 				if (expires.tv64 < expires_next.tv64)
 					expires_next = expires;
@@ -1414,7 +1415,8 @@
 			struct hrtimer *timer;
  
 			timer = rb_entry(node, struct hrtimer, node);
-			if (base->softirq_time.tv64 <= timer->expires.tv64)
+			if (base->softirq_time.tv64 <=
+					hrtimer_get_expires_tv64(timer))
 				break;
  
 			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {
@@ -1462,7 +1464,7 @@
  
 	do {
 		set_current_state(TASK_INTERRUPTIBLE);
-		hrtimer_start(&t->timer, t->timer.expires, mode);
+		hrtimer_start_expires(&t->timer, mode);
 		if (!hrtimer_active(&t->timer))
 			t->task = NULL;
  
@@ -1484,7 +1486,7 @@
 	struct timespec rmt;
 	ktime_t rem;
  
-	rem = ktime_sub(timer->expires, timer->base->get_time());
+	rem = hrtimer_expires_remaining(timer);
 	if (rem.tv64 <= 0)
 		return 0;
 	rmt = ktime_to_timespec(rem);
@@ -1503,7 +1505,7 @@
  
 	hrtimer_init_on_stack(&t.timer, restart->nanosleep.index,
 				HRTIMER_MODE_ABS);
-	t.timer.expires.tv64 = restart->nanosleep.expires;
+	hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
  
 	if (do_nanosleep(&t, HRTIMER_MODE_ABS))
 		goto out;
@@ -1530,7 +1532,7 @@
 	int ret = 0;
  
 	hrtimer_init_on_stack(&t.timer, clockid, mode);
-	t.timer.expires = timespec_to_ktime(*rqtp);
+	hrtimer_set_expires(&t.timer, timespec_to_ktime(*rqtp));
 	if (do_nanosleep(&t, mode))
 		goto out;
  
@@ -1550,7 +1552,7 @@
 	restart->fn = hrtimer_nanosleep_restart;
 	restart->nanosleep.index = t.timer.base->index;
 	restart->nanosleep.rmtp = rmtp;
-	restart->nanosleep.expires = t.timer.expires.tv64;
+	restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
  
 	ret = -ERESTART_RESTARTBLOCK;
 out:
  
@@ -1724,11 +1726,11 @@
 	}
  
 	hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC, mode);
-	t.timer.expires = *expires;
+	hrtimer_set_expires(&t.timer, *expires);
  
 	hrtimer_init_sleeper(&t, current);
  
-	hrtimer_start(&t.timer, t.timer.expires, mode);
+	hrtimer_start_expires(&t.timer, mode);
 	if (!hrtimer_active(&t.timer))
 		t.task = NULL;
  
@@ -668,7 +668,7 @@
 	    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
 		timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
  
-	remaining = ktime_sub(timer->expires, now);
+	remaining = ktime_sub(hrtimer_get_expires(timer), now);
 	/* Return 0 only, when the timer is expired and not pending */
 	if (remaining.tv64 <= 0) {
 		/*
@@ -762,7 +762,7 @@
 	hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
 	timr->it.real.timer.function = posix_timer_fn;
  
-	timer->expires = timespec_to_ktime(new_setting->it_value);
+	hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
  
 	/* Convert interval */
 	timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
  
@@ -771,14 +771,12 @@
 	if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
 		/* Setup correct expiry time for relative timers */
 		if (mode == HRTIMER_MODE_REL) {
-			timer->expires =
-				ktime_add_safe(timer->expires,
-					       timer->base->get_time());
+			hrtimer_add_expires(timer, timer->base->get_time());
 		}
 		return 0;
 	}
  
-	hrtimer_start(timer, timer->expires, mode);
+	hrtimer_start_expires(timer, mode);
 	return 0;
 }
  
@@ -631,8 +631,7 @@
  
 	/* Setup the timer, when timeout != NULL */
 	if (unlikely(timeout)) {
-		hrtimer_start(&timeout->timer, timeout->timer.expires,
-			      HRTIMER_MODE_ABS);
+		hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
 		if (!hrtimer_active(&timeout->timer))
 			timeout->task = NULL;
 	}
@@ -221,9 +221,8 @@
  
 		now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
 		hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
-		hrtimer_start(&rt_b->rt_period_timer,
-			      rt_b->rt_period_timer.expires,
-			      HRTIMER_MODE_ABS);
+		hrtimer_start_expires(&rt_b->rt_period_timer,
+				HRTIMER_MODE_ABS);
 	}
 	spin_unlock(&rt_b->rt_runtime_lock);
 }
@@ -1058,7 +1057,7 @@
 	struct hrtimer *timer = &rq->hrtick_timer;
 	ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
  
-	timer->expires = time;
+	hrtimer_set_expires(timer, time);
  
 	if (rq == this_rq()) {
 		hrtimer_restart(timer);
@@ -142,8 +142,7 @@
 		time_state = TIME_OOP;
 		printk(KERN_NOTICE "Clock: "
 		       "inserting leap second 23:59:60 UTC\n");
-		leap_timer.expires = ktime_add_ns(leap_timer.expires,
-						  NSEC_PER_SEC);
+		hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
 		res = HRTIMER_RESTART;
 		break;
 	case TIME_DEL:
@@ -288,7 +288,7 @@
 				goto out;
 			}
  
-			ts->idle_tick = ts->sched_timer.expires;
+			ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
 			ts->tick_stopped = 1;
 			ts->idle_jiffies = last_jiffies;
 			rcu_enter_nohz();
  
  
@@ -419,21 +419,21 @@
 	ts->tick_stopped  = 0;
 	ts->idle_exittime = now;
 	hrtimer_cancel(&ts->sched_timer);
-	ts->sched_timer.expires = ts->idle_tick;
+	hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
  
 	while (1) {
 		/* Forward the time to expire in the future */
 		hrtimer_forward(&ts->sched_timer, now, tick_period);
  
 		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
-			hrtimer_start(&ts->sched_timer,
-				      ts->sched_timer.expires,
+			hrtimer_start_expires(&ts->sched_timer,
 				      HRTIMER_MODE_ABS);
 			/* Check, if the timer was already in the past */
 			if (hrtimer_active(&ts->sched_timer))
 				break;
 		} else {
-			if (!tick_program_event(ts->sched_timer.expires, 0))
+			if (!tick_program_event(
+				hrtimer_get_expires(&ts->sched_timer), 0))
 				break;
 		}
 		/* Update jiffies and reread time */
@@ -446,7 +446,7 @@
 static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
 {
 	hrtimer_forward(&ts->sched_timer, now, tick_period);
-	return tick_program_event(ts->sched_timer.expires, 0);
+	return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
 }
  
 /*
@@ -529,7 +529,7 @@
 	next = tick_init_jiffy_update();
  
 	for (;;) {
-		ts->sched_timer.expires = next;
+		hrtimer_set_expires(&ts->sched_timer, next);
 		if (!tick_program_event(next, 0))
 			break;
 		next = ktime_add(next, tick_period);
  
  
@@ -625,16 +625,15 @@
 	ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
  
 	/* Get the next period (per cpu) */
-	ts->sched_timer.expires = tick_init_jiffy_update();
+	hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
 	offset = ktime_to_ns(tick_period) >> 1;
 	do_div(offset, num_possible_cpus());
 	offset *= smp_processor_id();
-	ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
+	hrtimer_add_expires_ns(&ts->sched_timer, offset);
  
 	for (;;) {
 		hrtimer_forward(&ts->sched_timer, now, tick_period);
-		hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,
-			      HRTIMER_MODE_ABS);
+		hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS);
 		/* Check, if the timer was already in the past */
 		if (hrtimer_active(&ts->sched_timer))
 			break;
@@ -66,8 +66,8 @@
 #endif
 	SEQ_printf(m, "\n");
 	SEQ_printf(m, " # expires at %Lu nsecs [in %Ld nsecs]\n",
-		(unsigned long long)ktime_to_ns(timer->expires),
-		(long long)(ktime_to_ns(timer->expires) - now));
+		(unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),
+		(long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));
 }
  
 static void
...	...	@@ -1299,10 +1299,9 @@
1299	1299	hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC,
1300	1300	HRTIMER_MODE_ABS);
1301	1301	hrtimer_init_sleeper(&t, current);
1302		- t.timer.expires = *abs_time;
	1302	+ hrtimer_set_expires(&t.timer, *abs_time);
1303	1303
1304		- hrtimer_start(&t.timer, t.timer.expires,
1305		- HRTIMER_MODE_ABS);
	1304	+ hrtimer_start_expires(&t.timer, HRTIMER_MODE_ABS);
1306	1305	if (!hrtimer_active(&t.timer))
1307	1306	t.task = NULL;
1308	1307
...	...	@@ -1404,7 +1403,7 @@
1404	1403	hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,
1405	1404	HRTIMER_MODE_ABS);
1406	1405	hrtimer_init_sleeper(to, current);
1407		- to->timer.expires = *time;
	1406	+ hrtimer_set_expires(&to->timer, *time);
1408	1407	}
1409	1408
1410	1409	q.pi_state = NULL;
...	...	@@ -517,7 +517,7 @@
517	517	if (!base->first)
518	518	continue;
519	519	timer = rb_entry(base->first, struct hrtimer, node);
520		- expires = ktime_sub(timer->expires, base->offset);
	520	+ expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
521	521	if (expires.tv64 < cpu_base->expires_next.tv64)
522	522	cpu_base->expires_next = expires;
523	523	}
524	524
...	...	@@ -539,10 +539,10 @@
539	539	struct hrtimer_clock_base *base)
540	540	{
541	541	ktime_t *expires_next = &__get_cpu_var(hrtimer_bases).expires_next;
542		- ktime_t expires = ktime_sub(timer->expires, base->offset);
	542	+ ktime_t expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
543	543	int res;
544	544
545		- WARN_ON_ONCE(timer->expires.tv64 < 0);
	545	+ WARN_ON_ONCE(hrtimer_get_expires_tv64(timer) < 0);
546	546
547	547	/*
548	548	* When the callback is running, we do not reprogram the clock event
...	...	@@ -794,7 +794,7 @@
794	794	u64 orun = 1;
795	795	ktime_t delta;
796	796
797		- delta = ktime_sub(now, timer->expires);
	797	+ delta = ktime_sub(now, hrtimer_get_expires(timer));
798	798
799	799	if (delta.tv64 < 0)
800	800	return 0;
...	...	@@ -806,8 +806,8 @@
806	806	s64 incr = ktime_to_ns(interval);
807	807
808	808	orun = ktime_divns(delta, incr);
809		- timer->expires = ktime_add_ns(timer->expires, incr * orun);
810		- if (timer->expires.tv64 > now.tv64)
	809	+ hrtimer_add_expires_ns(timer, incr * orun);
	810	+ if (hrtimer_get_expires_tv64(timer) > now.tv64)
811	811	return orun;
812	812	/*
813	813	* This (and the ktime_add() below) is the
...	...	@@ -815,7 +815,7 @@
815	815	*/
816	816	orun++;
817	817	}
818		- timer->expires = ktime_add_safe(timer->expires, interval);
	818	+ hrtimer_add_expires(timer, interval);
819	819
820	820	return orun;
821	821	}
...	...	@@ -847,7 +847,8 @@
847	847	* We dont care about collisions. Nodes with
848	848	* the same expiry time stay together.
849	849	*/
850		- if (timer->expires.tv64 < entry->expires.tv64) {
	850	+ if (hrtimer_get_expires_tv64(timer) <
	851	+ hrtimer_get_expires_tv64(entry)) {
851	852	link = &(*link)->rb_left;
852	853	} else {
853	854	link = &(*link)->rb_right;
...	...	@@ -982,7 +983,7 @@
982	983	#endif
983	984	}
984	985
985		- timer->expires = tim;
	986	+ hrtimer_set_expires(timer, tim);
986	987
987	988	timer_stats_hrtimer_set_start_info(timer);
988	989
...	...	@@ -1076,7 +1077,7 @@
1076	1077	ktime_t rem;
1077	1078
1078	1079	base = lock_hrtimer_base(timer, &flags);
1079		- rem = ktime_sub(timer->expires, base->get_time());
	1080	+ rem = hrtimer_expires_remaining(timer);
1080	1081	unlock_hrtimer_base(timer, &flags);
1081	1082
1082	1083	return rem;
...	...	@@ -1108,7 +1109,7 @@
1108	1109	continue;
1109	1110
1110	1111	timer = rb_entry(base->first, struct hrtimer, node);
1111		- delta.tv64 = timer->expires.tv64;
	1112	+ delta.tv64 = hrtimer_get_expires_tv64(timer);
1112	1113	delta = ktime_sub(delta, base->get_time());
1113	1114	if (delta.tv64 < mindelta.tv64)
1114	1115	mindelta.tv64 = delta.tv64;
1115	1116
...	...	@@ -1308,10 +1309,10 @@
1308	1309
1309	1310	timer = rb_entry(node, struct hrtimer, node);
1310	1311
1311		- if (basenow.tv64 < timer->expires.tv64) {
	1312	+ if (basenow.tv64 < hrtimer_get_expires_tv64(timer)) {
1312	1313	ktime_t expires;
1313	1314
1314		- expires = ktime_sub(timer->expires,
	1315	+ expires = ktime_sub(hrtimer_get_expires(timer),
1315	1316	base->offset);
1316	1317	if (expires.tv64 < expires_next.tv64)
1317	1318	expires_next = expires;
...	...	@@ -1414,7 +1415,8 @@
1414	1415	struct hrtimer *timer;
1415	1416
1416	1417	timer = rb_entry(node, struct hrtimer, node);
1417		- if (base->softirq_time.tv64 <= timer->expires.tv64)
	1418	+ if (base->softirq_time.tv64 <=
	1419	+ hrtimer_get_expires_tv64(timer))
1418	1420	break;
1419	1421
1420	1422	if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {
...	...	@@ -1462,7 +1464,7 @@
1462	1464
1463	1465	do {
1464	1466	set_current_state(TASK_INTERRUPTIBLE);
1465		- hrtimer_start(&t->timer, t->timer.expires, mode);
	1467	+ hrtimer_start_expires(&t->timer, mode);
1466	1468	if (!hrtimer_active(&t->timer))
1467	1469	t->task = NULL;
1468	1470
...	...	@@ -1484,7 +1486,7 @@
1484	1486	struct timespec rmt;
1485	1487	ktime_t rem;
1486	1488
1487		- rem = ktime_sub(timer->expires, timer->base->get_time());
	1489	+ rem = hrtimer_expires_remaining(timer);
1488	1490	if (rem.tv64 <= 0)
1489	1491	return 0;
1490	1492	rmt = ktime_to_timespec(rem);
...	...	@@ -1503,7 +1505,7 @@
1503	1505
1504	1506	hrtimer_init_on_stack(&t.timer, restart->nanosleep.index,
1505	1507	HRTIMER_MODE_ABS);
1506		- t.timer.expires.tv64 = restart->nanosleep.expires;
	1508	+ hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
1507	1509
1508	1510	if (do_nanosleep(&t, HRTIMER_MODE_ABS))
1509	1511	goto out;
...	...	@@ -1530,7 +1532,7 @@
1530	1532	int ret = 0;
1531	1533
1532	1534	hrtimer_init_on_stack(&t.timer, clockid, mode);
1533		- t.timer.expires = timespec_to_ktime(*rqtp);
	1535	+ hrtimer_set_expires(&t.timer, timespec_to_ktime(*rqtp));
1534	1536	if (do_nanosleep(&t, mode))
1535	1537	goto out;
1536	1538
...	...	@@ -1550,7 +1552,7 @@
1550	1552	restart->fn = hrtimer_nanosleep_restart;
1551	1553	restart->nanosleep.index = t.timer.base->index;
1552	1554	restart->nanosleep.rmtp = rmtp;
1553		- restart->nanosleep.expires = t.timer.expires.tv64;
	1555	+ restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
1554	1556
1555	1557	ret = -ERESTART_RESTARTBLOCK;
1556	1558	out:
1557	1559
...	...	@@ -1724,11 +1726,11 @@
1724	1726	}
1725	1727
1726	1728	hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC, mode);
1727		- t.timer.expires = *expires;
	1729	+ hrtimer_set_expires(&t.timer, *expires);
1728	1730
1729	1731	hrtimer_init_sleeper(&t, current);
1730	1732
1731		- hrtimer_start(&t.timer, t.timer.expires, mode);
	1733	+ hrtimer_start_expires(&t.timer, mode);
1732	1734	if (!hrtimer_active(&t.timer))
1733	1735	t.task = NULL;
1734	1736
...	...	@@ -668,7 +668,7 @@
668	668	(timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
669	669	timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
670	670
671		- remaining = ktime_sub(timer->expires, now);
	671	+ remaining = ktime_sub(hrtimer_get_expires(timer), now);
672	672	/* Return 0 only, when the timer is expired and not pending */
673	673	if (remaining.tv64 <= 0) {
674	674	/*
...	...	@@ -762,7 +762,7 @@
762	762	hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
763	763	timr->it.real.timer.function = posix_timer_fn;
764	764
765		- timer->expires = timespec_to_ktime(new_setting->it_value);
	765	+ hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
766	766
767	767	/* Convert interval */
768	768	timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
769	769
...	...	@@ -771,14 +771,12 @@
771	771	if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
772	772	/* Setup correct expiry time for relative timers */
773	773	if (mode == HRTIMER_MODE_REL) {
774		- timer->expires =
775		- ktime_add_safe(timer->expires,
776		- timer->base->get_time());
	774	+ hrtimer_add_expires(timer, timer->base->get_time());
777	775	}
778	776	return 0;
779	777	}
780	778
781		- hrtimer_start(timer, timer->expires, mode);
	779	+ hrtimer_start_expires(timer, mode);
782	780	return 0;
783	781	}
784	782
...	...	@@ -631,8 +631,7 @@
631	631
632	632	/* Setup the timer, when timeout != NULL */
633	633	if (unlikely(timeout)) {
634		- hrtimer_start(&timeout->timer, timeout->timer.expires,
635		- HRTIMER_MODE_ABS);
	634	+ hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
636	635	if (!hrtimer_active(&timeout->timer))
637	636	timeout->task = NULL;
638	637	}
...	...	@@ -221,9 +221,8 @@
221	221
222	222	now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
223	223	hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
224		- hrtimer_start(&rt_b->rt_period_timer,
225		- rt_b->rt_period_timer.expires,
226		- HRTIMER_MODE_ABS);
	224	+ hrtimer_start_expires(&rt_b->rt_period_timer,
	225	+ HRTIMER_MODE_ABS);
227	226	}
228	227	spin_unlock(&rt_b->rt_runtime_lock);
229	228	}
...	...	@@ -1058,7 +1057,7 @@
1058	1057	struct hrtimer *timer = &rq->hrtick_timer;
1059	1058	ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
1060	1059
1061		- timer->expires = time;
	1060	+ hrtimer_set_expires(timer, time);
1062	1061
1063	1062	if (rq == this_rq()) {
1064	1063	hrtimer_restart(timer);
...	...	@@ -142,8 +142,7 @@
142	142	time_state = TIME_OOP;
143	143	printk(KERN_NOTICE "Clock: "
144	144	"inserting leap second 23:59:60 UTC\n");
145		- leap_timer.expires = ktime_add_ns(leap_timer.expires,
146		- NSEC_PER_SEC);
	145	+ hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
147	146	res = HRTIMER_RESTART;
148	147	break;
149	148	case TIME_DEL:
...	...	@@ -288,7 +288,7 @@
288	288	goto out;
289	289	}
290	290
291		- ts->idle_tick = ts->sched_timer.expires;
	291	+ ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
292	292	ts->tick_stopped = 1;
293	293	ts->idle_jiffies = last_jiffies;
294	294	rcu_enter_nohz();
295	295
296	296
...	...	@@ -419,21 +419,21 @@
419	419	ts->tick_stopped = 0;
420	420	ts->idle_exittime = now;
421	421	hrtimer_cancel(&ts->sched_timer);
422		- ts->sched_timer.expires = ts->idle_tick;
	422	+ hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
423	423
424	424	while (1) {
425	425	/* Forward the time to expire in the future */
426	426	hrtimer_forward(&ts->sched_timer, now, tick_period);
427	427
428	428	if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
429		- hrtimer_start(&ts->sched_timer,
430		- ts->sched_timer.expires,
	429	+ hrtimer_start_expires(&ts->sched_timer,
431	430	HRTIMER_MODE_ABS);
432	431	/* Check, if the timer was already in the past */
433	432	if (hrtimer_active(&ts->sched_timer))
434	433	break;
435	434	} else {
436		- if (!tick_program_event(ts->sched_timer.expires, 0))
	435	+ if (!tick_program_event(
	436	+ hrtimer_get_expires(&ts->sched_timer), 0))
437	437	break;
438	438	}
439	439	/* Update jiffies and reread time */
...	...	@@ -446,7 +446,7 @@
446	446	static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
447	447	{
448	448	hrtimer_forward(&ts->sched_timer, now, tick_period);
449		- return tick_program_event(ts->sched_timer.expires, 0);
	449	+ return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
450	450	}
451	451
452	452	/*
...	...	@@ -529,7 +529,7 @@
529	529	next = tick_init_jiffy_update();
530	530
531	531	for (;;) {
532		- ts->sched_timer.expires = next;
	532	+ hrtimer_set_expires(&ts->sched_timer, next);
533	533	if (!tick_program_event(next, 0))
534	534	break;
535	535	next = ktime_add(next, tick_period);
536	536
537	537
...	...	@@ -625,16 +625,15 @@
625	625	ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
626	626
627	627	/* Get the next period (per cpu) */
628		- ts->sched_timer.expires = tick_init_jiffy_update();
	628	+ hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
629	629	offset = ktime_to_ns(tick_period) >> 1;
630	630	do_div(offset, num_possible_cpus());
631	631	offset *= smp_processor_id();
632		- ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
	632	+ hrtimer_add_expires_ns(&ts->sched_timer, offset);
633	633
634	634	for (;;) {
635	635	hrtimer_forward(&ts->sched_timer, now, tick_period);
636		- hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,
637		- HRTIMER_MODE_ABS);
	636	+ hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS);
638	637	/* Check, if the timer was already in the past */
639	638	if (hrtimer_active(&ts->sched_timer))
640	639	break;
...	...	@@ -66,8 +66,8 @@
66	66	#endif
67	67	SEQ_printf(m, "\n");
68	68	SEQ_printf(m, " # expires at %Lu nsecs [in %Ld nsecs]\n",
69		- (unsigned long long)ktime_to_ns(timer->expires),
70		- (long long)(ktime_to_ns(timer->expires) - now));
	69	+ (unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),
	70	+ (long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));
71	71	}
72	72
73	73	static void