Commit d3ba5a9a authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Thomas Gleixner
Browse files

posix-timers: Make posix_clocks immutable 



There are no more modular users providing a posix clock. The register
function is now pointless so the posix clock array can be initialized
statically at compile time and the array including the various k_clock
structs can be marked 'const'.

Inspired by changes in the Grsecurity patch set, but done proper.

[ tglx: Massaged changelog and fixed the POSIX_TIMER=n case ]

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Cc: Mike Travis <mike.travis@hpe.com>
Cc: Dimitri Sivanich <sivanich@hpe.com>
Link: http://lkml.kernel.org/r/20170526090311.3377-3-hch@lst.de
parent 07903ada

include/linux/posix-timers.h

+5 −4
Original line number Diff line number Diff line
@@ -105,10 +105,11 @@ struct k_clock { 
			   struct itimerspec64 *cur_setting);

};



extern struct k_clock clock_posix_cpu;

extern struct k_clock clock_posix_dynamic;



void posix_timers_register_clock(const clockid_t clock_id, struct k_clock *new_clock);

extern const struct k_clock clock_posix_cpu;

extern const struct k_clock clock_posix_dynamic;

extern const struct k_clock clock_process;

extern const struct k_clock clock_thread;

extern const struct k_clock alarm_clock;



/* function to call to trigger timer event */

int posix_timer_event(struct k_itimer *timr, int si_private);

kernel/time/alarmtimer.c

+43 −46
Original line number Diff line number Diff line
@@ -307,38 +307,6 @@ static int alarmtimer_resume(struct device *dev) 
}

#endif



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->gettime());



	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);

}





/**

 * alarm_init - Initialize an alarm structure

 * @alarm: ptr to alarm to be initialized
@@ -488,6 +456,38 @@ u64 alarm_forward_now(struct alarm *alarm, ktime_t interval) 
}

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->gettime());



	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
@@ -846,6 +846,17 @@ out: 
	return ret;

}



const struct k_clock alarm_clock = {

	.clock_getres	= alarm_clock_getres,

	.clock_get	= alarm_clock_get,

	.timer_create	= alarm_timer_create,

	.timer_set	= alarm_timer_set,

	.timer_del	= alarm_timer_del,

	.timer_get	= alarm_timer_get,

	.nsleep		= alarm_timer_nsleep,

};

#endif /* CONFIG_POSIX_TIMERS */





/* Suspend hook structures */

static const struct dev_pm_ops alarmtimer_pm_ops = {
@@ -871,23 +882,9 @@ static int __init alarmtimer_init(void) 
	struct platform_device *pdev;

	int error = 0;

	int i;

	struct k_clock alarm_clock = {

		.clock_getres	= alarm_clock_getres,

		.clock_get	= alarm_clock_get,

		.timer_create	= alarm_timer_create,

		.timer_set	= alarm_timer_set,

		.timer_del	= alarm_timer_del,

		.timer_get	= alarm_timer_get,

		.nsleep		= alarm_timer_nsleep,

	};



	alarmtimer_rtc_timer_init();



	if (IS_ENABLED(CONFIG_POSIX_TIMERS)) {

		posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);

		posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);

	}



	/* Initialize alarm bases */

	alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;

	alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;

kernel/time/posix-clock.c

+1 −1
Original line number Diff line number Diff line
@@ -434,7 +434,7 @@ static int pc_timer_settime(struct k_itimer *kit, int flags, 
	return err;

}



struct k_clock clock_posix_dynamic = {

const struct k_clock clock_posix_dynamic = {

	.clock_getres	= pc_clock_getres,

	.clock_set	= pc_clock_settime,

	.clock_get	= pc_clock_gettime,

kernel/time/posix-cpu-timers.c

+13 −21
Original line number Diff line number Diff line
@@ -1413,7 +1413,7 @@ static int thread_cpu_timer_create(struct k_itimer *timer) 
	return posix_cpu_timer_create(timer);

}



struct k_clock clock_posix_cpu = {

const struct k_clock clock_posix_cpu = {

	.clock_getres	= posix_cpu_clock_getres,

	.clock_set	= posix_cpu_clock_set,

	.clock_get	= posix_cpu_clock_get,
@@ -1425,24 +1425,16 @@ struct k_clock clock_posix_cpu = { 
	.timer_get	= posix_cpu_timer_get,

};



static __init int init_posix_cpu_timers(void)

{

	struct k_clock process = {

const struct k_clock clock_process = {

	.clock_getres	= process_cpu_clock_getres,

	.clock_get	= process_cpu_clock_get,

	.timer_create	= process_cpu_timer_create,

	.nsleep		= process_cpu_nsleep,

	.nsleep_restart	= process_cpu_nsleep_restart,

};

	struct k_clock thread = {



const struct k_clock clock_thread = {

	.clock_getres	= thread_cpu_clock_getres,

	.clock_get	= thread_cpu_clock_get,

	.timer_create	= thread_cpu_timer_create,

};
 


	posix_timers_register_clock(CLOCK_PROCESS_CPUTIME_ID, &process);

	posix_timers_register_clock(CLOCK_THREAD_CPUTIME_ID, &thread);



	return 0;

}

__initcall(init_posix_cpu_timers);

kernel/time/posix-timers.c

+89 −102
Original line number Diff line number Diff line
@@ -125,8 +125,6 @@ static DEFINE_SPINLOCK(hash_lock); 
 *	    which we beg off on and pass to do_sys_settimeofday().

 */



static struct k_clock posix_clocks[MAX_CLOCKS];



/*

 * These ones are defined below.

 */
@@ -280,12 +278,8 @@ static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp) 
	return 0;

}



/*

 * Initialize everything, well, just everything in Posix clocks/timers ;)

 */

static __init int init_posix_timers(void)

{

	struct k_clock clock_realtime = {



static const struct k_clock clock_realtime = {

	.clock_getres	= posix_get_hrtimer_res,

	.clock_get	= posix_clock_realtime_get,

	.clock_set	= posix_clock_realtime_set,
@@ -297,7 +291,8 @@ static __init int init_posix_timers(void) 
	.timer_get	= common_timer_get,

	.timer_del	= common_timer_del,

};

	struct k_clock clock_monotonic = {



static const struct k_clock clock_monotonic = {

	.clock_getres	= posix_get_hrtimer_res,

	.clock_get	= posix_ktime_get_ts,

	.nsleep		= common_nsleep,
@@ -307,19 +302,23 @@ static __init int init_posix_timers(void) 
	.timer_get	= common_timer_get,

	.timer_del	= common_timer_del,

};

	struct k_clock clock_monotonic_raw = {



static const struct k_clock clock_monotonic_raw = {

	.clock_getres	= posix_get_hrtimer_res,

	.clock_get	= posix_get_monotonic_raw,

};

	struct k_clock clock_realtime_coarse = {



static const struct k_clock clock_realtime_coarse = {

	.clock_getres	= posix_get_coarse_res,

	.clock_get	= posix_get_realtime_coarse,

};

	struct k_clock clock_monotonic_coarse = {



static const struct k_clock clock_monotonic_coarse = {

	.clock_getres	= posix_get_coarse_res,

	.clock_get	= posix_get_monotonic_coarse,

};

	struct k_clock clock_tai = {



static const struct k_clock clock_tai = {

	.clock_getres	= posix_get_hrtimer_res,

	.clock_get	= posix_get_tai,

	.nsleep		= common_nsleep,
@@ -329,7 +328,8 @@ static __init int init_posix_timers(void) 
	.timer_get	= common_timer_get,

	.timer_del	= common_timer_del,

};

	struct k_clock clock_boottime = {



static const struct k_clock clock_boottime = {

	.clock_getres	= posix_get_hrtimer_res,

	.clock_get	= posix_get_boottime,

	.nsleep		= common_nsleep,
@@ -340,14 +340,25 @@ static __init int init_posix_timers(void) 
	.timer_del	= common_timer_del,

};



	posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);

	posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);

	posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);

	posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);

	posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);

	posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);

	posix_timers_register_clock(CLOCK_TAI, &clock_tai);

static const struct k_clock * const posix_clocks[] = {

	[CLOCK_REALTIME]		= &clock_realtime,

	[CLOCK_MONOTONIC]		= &clock_monotonic,

	[CLOCK_PROCESS_CPUTIME_ID]	= &clock_process,

	[CLOCK_THREAD_CPUTIME_ID]	= &clock_thread,

	[CLOCK_MONOTONIC_RAW]		= &clock_monotonic_raw,

	[CLOCK_REALTIME_COARSE]		= &clock_realtime_coarse,

	[CLOCK_MONOTONIC_COARSE]	= &clock_monotonic_coarse,

	[CLOCK_BOOTTIME]		= &clock_boottime,

	[CLOCK_REALTIME_ALARM]		= &alarm_clock,

	[CLOCK_BOOTTIME_ALARM]		= &alarm_clock,

	[CLOCK_TAI]			= &clock_tai,

};



/*

 * Initialize everything, well, just everything in Posix clocks/timers ;)

 */

static __init int init_posix_timers(void)

{

	posix_timers_cache = kmem_cache_create("posix_timers_cache",

					sizeof (struct k_itimer), 0, SLAB_PANIC,

					NULL);
@@ -521,30 +532,6 @@ static struct pid *good_sigevent(sigevent_t * event) 
	return task_pid(rtn);

}



void posix_timers_register_clock(const clockid_t clock_id,

				 struct k_clock *new_clock)

{

	if ((unsigned) clock_id >= MAX_CLOCKS) {

		printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",

		       clock_id);

		return;

	}



	if (!new_clock->clock_get) {

		printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",

		       clock_id);

		return;

	}

	if (!new_clock->clock_getres) {

		printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",

		       clock_id);

		return;

	}



	posix_clocks[clock_id] = *new_clock;

}

EXPORT_SYMBOL_GPL(posix_timers_register_clock);



static struct k_itimer * alloc_posix_timer(void)

{

	struct k_itimer *tmr;
@@ -581,15 +568,15 @@ static void release_posix_timer(struct k_itimer *tmr, int it_id_set) 
	call_rcu(&tmr->it.rcu, k_itimer_rcu_free);

}



static struct k_clock *clockid_to_kclock(const clockid_t id)

static const struct k_clock *clockid_to_kclock(const clockid_t id)

{

	if (id < 0)

		return (id & CLOCKFD_MASK) == CLOCKFD ?

			&clock_posix_dynamic : &clock_posix_cpu;



	if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)

	if (id >= ARRAY_SIZE(posix_clocks) || !posix_clocks[id])

		return NULL;

	return &posix_clocks[id];

	return posix_clocks[id];

}



static int common_timer_create(struct k_itimer *new_timer)
@@ -604,7 +591,7 @@ SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock, 
		struct sigevent __user *, timer_event_spec,

		timer_t __user *, created_timer_id)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct k_itimer *new_timer;

	int error, new_timer_id;

	sigevent_t event;
@@ -781,7 +768,7 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id, 
	struct itimerspec64 cur_setting64;

	struct itimerspec cur_setting;

	struct k_itimer *timr;

	struct k_clock *kc;

	const struct k_clock *kc;

	unsigned long flags;

	int ret = 0;
@@ -890,7 +877,7 @@ SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags, 
	struct itimerspec new_spec, old_spec;

	struct k_itimer *timr;

	unsigned long flag;

	struct k_clock *kc;

	const struct k_clock *kc;

	int error = 0;



	if (!new_setting)
@@ -939,7 +926,7 @@ static int common_timer_del(struct k_itimer *timer) 


static inline int timer_delete_hook(struct k_itimer *timer)

{

	struct k_clock *kc = clockid_to_kclock(timer->it_clock);

	const struct k_clock *kc = clockid_to_kclock(timer->it_clock);



	if (WARN_ON_ONCE(!kc || !kc->timer_del))

		return -EINVAL;
@@ -1018,7 +1005,7 @@ void exit_itimers(struct signal_struct *sig) 
SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,

		const struct timespec __user *, tp)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct timespec64 new_tp64;

	struct timespec new_tp;
@@ -1035,7 +1022,7 @@ SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, 
SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,

		struct timespec __user *,tp)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct timespec64 kernel_tp64;

	struct timespec kernel_tp;

	int error;
@@ -1055,7 +1042,7 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, 
SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,

		struct timex __user *, utx)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct timex ktx;

	int err;
@@ -1078,7 +1065,7 @@ SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock, 
SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,

		struct timespec __user *, tp)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct timespec64 rtn_tp64;

	struct timespec rtn_tp;

	int error;
@@ -1110,7 +1097,7 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 
		const struct timespec __user *, rqtp,

		struct timespec __user *, rmtp)

{

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);

	struct timespec64 t64;

	struct timespec t;
@@ -1136,7 +1123,7 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 
long clock_nanosleep_restart(struct restart_block *restart_block)

{

	clockid_t which_clock = restart_block->nanosleep.clockid;

	struct k_clock *kc = clockid_to_kclock(which_clock);

	const struct k_clock *kc = clockid_to_kclock(which_clock);



	if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))

		return -EINVAL;

CRA Git | Maintained and supported by SUSTech CRA and CCSE