Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 11ffa9d6 authored by Todd Poynor's avatar Todd Poynor Committed by John Stultz
Browse files

timerfd: Add alarm timers 



Add support for clocks CLOCK_REALTIME_ALARM and CLOCK_BOOTTIME_ALARM,
thereby enabling wakeup alarm timers via file descriptors.

Signed-off-by: default avatarTodd Poynor <toddpoynor@google.com>
Signed-off-by: default avatarJohn Stultz <john.stultz@linaro.org>
parent 6cffe00f

fs/timerfd.c

+108 −23
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
 *

 */



#include <linux/alarmtimer.h>

#include <linux/file.h>

#include <linux/poll.h>

#include <linux/init.h>
@@ -26,7 +27,10 @@ 
#include <linux/rcupdate.h>



struct timerfd_ctx {

	union {

		struct hrtimer tmr;

		struct alarm alarm;

	} t;

	ktime_t tintv;

	ktime_t moffs;

	wait_queue_head_t wqh;
@@ -41,14 +45,19 @@ struct timerfd_ctx { 
static LIST_HEAD(cancel_list);

static DEFINE_SPINLOCK(cancel_lock);



static inline bool isalarm(struct timerfd_ctx *ctx)

{

	return ctx->clockid == CLOCK_REALTIME_ALARM ||

		ctx->clockid == CLOCK_BOOTTIME_ALARM;

}



/*

 * This gets called when the timer event triggers. We set the "expired"

 * flag, but we do not re-arm the timer (in case it's necessary,

 * tintv.tv64 != 0) until the timer is accessed.

 */

static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr)

static void timerfd_triggered(struct timerfd_ctx *ctx)

{

	struct timerfd_ctx *ctx = container_of(htmr, struct timerfd_ctx, tmr);

	unsigned long flags;



	spin_lock_irqsave(&ctx->wqh.lock, flags);
@@ -56,10 +65,25 @@ static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr) 
	ctx->ticks++;

	wake_up_locked(&ctx->wqh);

	spin_unlock_irqrestore(&ctx->wqh.lock, flags);

}



static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr)

{

	struct timerfd_ctx *ctx = container_of(htmr, struct timerfd_ctx,

					       t.tmr);

	timerfd_triggered(ctx);

	return HRTIMER_NORESTART;

}



static enum alarmtimer_restart timerfd_alarmproc(struct alarm *alarm,

	ktime_t now)

{

	struct timerfd_ctx *ctx = container_of(alarm, struct timerfd_ctx,

					       t.alarm);

	timerfd_triggered(ctx);

	return ALARMTIMER_NORESTART;

}



/*

 * Called when the clock was set to cancel the timers in the cancel

 * list. This will wake up processes waiting on these timers. The
@@ -107,8 +131,9 @@ static bool timerfd_canceled(struct timerfd_ctx *ctx) 


static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)

{

	if (ctx->clockid == CLOCK_REALTIME && (flags & TFD_TIMER_ABSTIME) &&

	    (flags & TFD_TIMER_CANCEL_ON_SET)) {

	if ((ctx->clockid == CLOCK_REALTIME ||

	     ctx->clockid == CLOCK_REALTIME_ALARM) &&

	    (flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) {

		if (!ctx->might_cancel) {

			ctx->might_cancel = true;

			spin_lock(&cancel_lock);
@@ -124,7 +149,11 @@ static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx) 
{

	ktime_t remaining;



	remaining = hrtimer_expires_remaining(&ctx->tmr);

	if (isalarm(ctx))

		remaining = alarm_expires_remaining(&ctx->t.alarm);

	else

		remaining = hrtimer_expires_remaining(&ctx->t.tmr);



	return remaining.tv64 < 0 ? ktime_set(0, 0): remaining;

}
@@ -142,11 +171,28 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags, 
	ctx->expired = 0;

	ctx->ticks = 0;

	ctx->tintv = timespec_to_ktime(ktmr->it_interval);

	hrtimer_init(&ctx->tmr, clockid, htmode);

	hrtimer_set_expires(&ctx->tmr, texp);

	ctx->tmr.function = timerfd_tmrproc;



	if (isalarm(ctx)) {

		alarm_init(&ctx->t.alarm,

			   ctx->clockid == CLOCK_REALTIME_ALARM ?

			   ALARM_REALTIME : ALARM_BOOTTIME,

			   timerfd_alarmproc);

	} else {

		hrtimer_init(&ctx->t.tmr, clockid, htmode);

		hrtimer_set_expires(&ctx->t.tmr, texp);

		ctx->t.tmr.function = timerfd_tmrproc;

	}



	if (texp.tv64 != 0) {

		hrtimer_start(&ctx->tmr, texp, htmode);

		if (isalarm(ctx)) {

			if (flags & TFD_TIMER_ABSTIME)

				alarm_start(&ctx->t.alarm, texp);

			else

				alarm_start_relative(&ctx->t.alarm, texp);

		} else {

			hrtimer_start(&ctx->t.tmr, texp, htmode);

		}



		if (timerfd_canceled(ctx))

			return -ECANCELED;

	}
@@ -158,7 +204,11 @@ static int timerfd_release(struct inode *inode, struct file *file) 
	struct timerfd_ctx *ctx = file->private_data;



	timerfd_remove_cancel(ctx);

	hrtimer_cancel(&ctx->tmr);



	if (isalarm(ctx))

		alarm_cancel(&ctx->t.alarm);

	else

		hrtimer_cancel(&ctx->t.tmr);

	kfree_rcu(ctx, rcu);

	return 0;

}
@@ -215,9 +265,15 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, 
			 * callback to avoid DoS attacks specifying a very

			 * short timer period.

			 */

			ticks += hrtimer_forward_now(&ctx->tmr,

			if (isalarm(ctx)) {

				ticks += alarm_forward_now(

					&ctx->t.alarm, ctx->tintv) - 1;

				alarm_restart(&ctx->t.alarm);

			} else {

				ticks += hrtimer_forward_now(&ctx->t.tmr,

							     ctx->tintv) - 1;

			hrtimer_restart(&ctx->tmr);

				hrtimer_restart(&ctx->t.tmr);

			}

		}

		ctx->expired = 0;

		ctx->ticks = 0;
@@ -259,7 +315,9 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 


	if ((flags & ~TFD_CREATE_FLAGS) ||

	    (clockid != CLOCK_MONOTONIC &&

	     clockid != CLOCK_REALTIME))

	     clockid != CLOCK_REALTIME &&

	     clockid != CLOCK_REALTIME_ALARM &&

	     clockid != CLOCK_BOOTTIME_ALARM))

		return -EINVAL;



	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
@@ -268,7 +326,15 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 


	init_waitqueue_head(&ctx->wqh);

	ctx->clockid = clockid;

	hrtimer_init(&ctx->tmr, clockid, HRTIMER_MODE_ABS);



	if (isalarm(ctx))

		alarm_init(&ctx->t.alarm,

			   ctx->clockid == CLOCK_REALTIME_ALARM ?

			   ALARM_REALTIME : ALARM_BOOTTIME,

			   timerfd_alarmproc);

	else

		hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS);



	ctx->moffs = ktime_get_monotonic_offset();



	ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx,
@@ -305,8 +371,14 @@ static int do_timerfd_settime(int ufd, int flags, 
	 */

	for (;;) {

		spin_lock_irq(&ctx->wqh.lock);

		if (hrtimer_try_to_cancel(&ctx->tmr) >= 0)



		if (isalarm(ctx)) {

			if (alarm_try_to_cancel(&ctx->t.alarm) >= 0)

				break;

		} else {

			if (hrtimer_try_to_cancel(&ctx->t.tmr) >= 0)

				break;

		}

		spin_unlock_irq(&ctx->wqh.lock);

		cpu_relax();

	}
@@ -317,8 +389,12 @@ static int do_timerfd_settime(int ufd, int flags, 
	 * We do not update "ticks" and "expired" since the timer will be

	 * re-programmed again in the following timerfd_setup() call.

	 */

	if (ctx->expired && ctx->tintv.tv64)

		hrtimer_forward_now(&ctx->tmr, ctx->tintv);

	if (ctx->expired && ctx->tintv.tv64) {

		if (isalarm(ctx))

			alarm_forward_now(&ctx->t.alarm, ctx->tintv);

		else

			hrtimer_forward_now(&ctx->t.tmr, ctx->tintv);

	}



	old->it_value = ktime_to_timespec(timerfd_get_remaining(ctx));

	old->it_interval = ktime_to_timespec(ctx->tintv);
@@ -345,9 +421,18 @@ static int do_timerfd_gettime(int ufd, struct itimerspec *t) 
	spin_lock_irq(&ctx->wqh.lock);

	if (ctx->expired && ctx->tintv.tv64) {

		ctx->expired = 0;



		if (isalarm(ctx)) {

			ctx->ticks +=

			hrtimer_forward_now(&ctx->tmr, ctx->tintv) - 1;

		hrtimer_restart(&ctx->tmr);

				alarm_forward_now(

					&ctx->t.alarm, ctx->tintv) - 1;

			alarm_restart(&ctx->t.alarm);

		} else {

			ctx->ticks +=

				hrtimer_forward_now(&ctx->t.tmr, ctx->tintv)

				- 1;

			hrtimer_restart(&ctx->t.tmr);

		}

	}

	t->it_value = ktime_to_timespec(timerfd_get_remaining(ctx));

	t->it_interval = ktime_to_timespec(ctx->tintv);