[meta-intel] [PATCH 2/2] meta-tlk: Add linux-intel bbappend
California Sullivan
california.l.sullivan at intel.com
Tue May 30 15:04:18 PDT 2017
This bbappend adds the time limited kernel patch and configuration
options. Unlike linux-yocto, the patch is not integrated into the source
tree, so we have to add it here.
Signed-off-by: California Sullivan <california.l.sullivan at intel.com>
---
...w-the-optional-limiting-of-kernel-runtime.patch | 251 +++++++++++++++++++++
.../recipes-kernel/linux/linux-intel_%.bbappend | 3 +
2 files changed, 254 insertions(+)
create mode 100644 meta-tlk/recipes-kernel/linux/files/uptime-allow-the-optional-limiting-of-kernel-runtime.patch
create mode 100644 meta-tlk/recipes-kernel/linux/linux-intel_%.bbappend
diff --git a/meta-tlk/recipes-kernel/linux/files/uptime-allow-the-optional-limiting-of-kernel-runtime.patch b/meta-tlk/recipes-kernel/linux/files/uptime-allow-the-optional-limiting-of-kernel-runtime.patch
new file mode 100644
index 0000000..aa14305
--- /dev/null
+++ b/meta-tlk/recipes-kernel/linux/files/uptime-allow-the-optional-limiting-of-kernel-runtime.patch
@@ -0,0 +1,251 @@
+From a21e483b57c8c31beaa5063268ec35da375daf04 Mon Sep 17 00:00:00 2001
+From: Bruce Ashfield <bruce.ashfield at windriver.com>
+Date: Tue, 12 Jul 2011 10:26:50 -0400
+Subject: [PATCH] uptime: allow the optional limiting of kernel runtime
+
+Introduce the ability to limit the limit the uptime of a kernel.
+When enabled, these options set a maximum uptime on the kernel, and
+(optionally) trigger a clean reboot at expiration.
+
+This functionality may appear to be very close to the softdog watchdog
+implementation. It is. But can't be the softdog for several reasons:
+
+ - The soft watchdog should be available while this functionality is active
+ - The duration range is different between this and the softdog. The
+ timeout available here is potentially quite a bit longer.
+ - At expiration, there are different expiration requirements and actions.
+ - This functionality is specific to a particular use case and should
+ not impact mainline functionality
+
+To cleanly restart the kernel after one minute of uptime, the following
+config items would be required:
+
+ CONFIG_UPTIME_LIMITED_KERNEL=y
+ CONFIG_UPTIME_LIMIT_DURATION=1
+ CONFIG_UPTIME_LIMIT_KERNEL_REBOOT=y
+
+Signed-off-by: Bruce Ashfield <bruce.ashfield at windriver.com>
+
+diff --git a/init/Kconfig b/init/Kconfig
+index cac3f096050d..77d6d5fa1b1d 100644
+--- a/init/Kconfig
++++ b/init/Kconfig
+@@ -1376,6 +1376,31 @@ menuconfig EXPERT
+ environments which can tolerate a "non-standard" kernel.
+ Only use this if you really know what you are doing.
+
++config UPTIME_LIMITED_KERNEL
++ bool "Create a kernel with uptime limitations"
++ default n
++ help
++ Limit the amount of time a kernel can run. The associated UPTIME_LIMIT*
++ kernel config options should be used to tune the behaviour.
++
++config UPTIME_LIMIT_DURATION
++ int "Kernel uptime limit in minutes"
++ depends on UPTIME_LIMITED_KERNEL
++ range 0 14400
++ default 0
++ help
++ Define the uptime limitation on a kernel in minutes. Once
++ the defined time expires the kernel will emit a warning, cease
++ to be usable and eventually restart. The valid range is 0 (disable)
++ to 14400 (10 days)
++
++config UPTIME_LIMIT_KERNEL_REBOOT
++ bool "Reboot a time limited kernel at expiration"
++ depends on UPTIME_LIMITED_KERNEL
++ default y
++ help
++ Reboot an uptime limited kernel at expiration.
++
+ config UID16
+ bool "Enable 16-bit UID system calls" if EXPERT
+ depends on HAVE_UID16 && MULTIUSER
+diff --git a/kernel/Makefile b/kernel/Makefile
+index e2ec54e2b952..6b7bdddd624b 100644
+--- a/kernel/Makefile
++++ b/kernel/Makefile
+@@ -45,6 +45,7 @@ obj-$(CONFIG_FREEZER) += freezer.o
+ obj-$(CONFIG_PROFILING) += profile.o
+ obj-$(CONFIG_STACKTRACE) += stacktrace.o
+ obj-y += time/
++obj-$(CONFIG_UPTIME_LIMITED_KERNEL) += uptime_limit.o
+ obj-$(CONFIG_FUTEX) += futex.o
+ ifeq ($(CONFIG_COMPAT),y)
+ obj-$(CONFIG_FUTEX) += futex_compat.o
+diff --git a/kernel/uptime_limit.c b/kernel/uptime_limit.c
+new file mode 100644
+index 000000000000..b6a1a5e4f9d9
+--- /dev/null
++++ b/kernel/uptime_limit.c
+@@ -0,0 +1,166 @@
++/*
++ * uptime_limit.c
++ *
++ * This file contains the functions which can limit kernel uptime
++ *
++ * Copyright (C) 2011 Bruce Ashfield (bruce.ashfield at windriver.com)
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ * This functionality is somewhat close to the softdog watchdog
++ * implementation, but it cannot be used directly for several reasons:
++ *
++ * - The soft watchdog should be available while this functionality is active
++ * - The duration range is different between this and the softdog. The
++ * timeout available here is potentially quite a bit longer.
++ * - At expiration, there are different expiration requirements and actions.
++ * - This functionality is specific to a particular use case and should
++ * not impact mainline functionality
++ *
++ */
++#include <linux/kernel.h>
++#include <linux/reboot.h>
++#include <linux/timer.h>
++#include <linux/delay.h>
++#include <linux/kthread.h>
++
++#define UPTIME_LIMIT_IN_SECONDS (CONFIG_UPTIME_LIMIT_DURATION * 60)
++#define MIN(X, Y) ((X) <= (Y) ? (X) : (Y))
++#define TEN_MINUTES_IN_SECONDS 600
++
++enum uptime_expiration_type {
++ uptime_no_action,
++ uptime_reboot
++};
++
++static enum uptime_expiration_type uptime_expiration_action = uptime_no_action;
++static struct timer_list timelimit_timer;
++static struct task_struct *uptime_worker_task;
++
++static void timelimit_expire(unsigned long timeout_seconds)
++{
++ char msg[128];
++ int msglen = 127;
++
++ if (timeout_seconds) {
++ if (timeout_seconds >= 60)
++ snprintf(msg, msglen,
++ "Uptime: kernel validity duration has %d %s remaining\n",
++ (int) timeout_seconds / 60, "minute(s)");
++ else
++ snprintf(msg, msglen,
++ "Uptime: kernel validity duration has %d %s remaining\n",
++ (int) timeout_seconds, "seconds");
++
++ printk(KERN_CRIT "%s", msg);
++
++ timelimit_timer.expires = jiffies + timeout_seconds * HZ;
++ timelimit_timer.data = 0;
++ add_timer_on(&timelimit_timer, cpumask_first(cpu_online_mask));
++ } else {
++ printk(KERN_CRIT "Uptime: Kernel validity timeout has expired\n");
++#ifdef CONFIG_UPTIME_LIMIT_KERNEL_REBOOT
++ uptime_expiration_action = uptime_reboot;
++ wake_up_process(uptime_worker_task);
++ }
++#endif
++}
++
++/*
++ * This thread starts and then immediately goes to sleep. When it is woken
++ * up, it carries out the instructions left in uptime_expiration_action. If
++ * no action was specified it simply goes back to sleep.
++ */
++static int uptime_worker(void *unused)
++{
++ set_current_state(TASK_INTERRUPTIBLE);
++
++ while (!kthread_should_stop()) {
++ schedule();
++
++ if (kthread_should_stop())
++ break;
++
++ if (uptime_expiration_action == uptime_reboot) {
++ printk(KERN_CRIT "Uptime: restarting machine\n");
++ kernel_restart(NULL);
++ }
++
++ set_current_state(TASK_INTERRUPTIBLE);
++ }
++ __set_current_state(TASK_RUNNING);
++
++ return 0;
++}
++
++static int timeout_enable(int cpu)
++{
++ int err = 0;
++ int warning_limit;
++
++ /*
++ * Create an uptime worker thread. This thread is required since the
++ * safe version of kernel restart cannot be called from a
++ * non-interruptible context. Which means we cannot call it directly
++ * from a timer callback. So we arrange for the timer expiration to
++ * wakeup a thread, which performs the action.
++ */
++ uptime_worker_task = kthread_create(uptime_worker,
++ (void *)(unsigned long)cpu,
++ "uptime_worker/%d", cpu);
++ if (IS_ERR(uptime_worker_task)) {
++ printk(KERN_ERR "Uptime: task for cpu %i failed\n", cpu);
++ err = PTR_ERR(uptime_worker_task);
++ goto out;
++ }
++ /* bind to cpu0 to avoid migration and hot plug nastiness */
++ kthread_bind(uptime_worker_task, cpu);
++ wake_up_process(uptime_worker_task);
++
++ /* Create the timer that will wake the uptime thread at expiration */
++ init_timer(&timelimit_timer);
++ timelimit_timer.function = timelimit_expire;
++ /*
++ * Fire two timers. One warning timeout and the final timer
++ * which will carry out the expiration action. The warning timer will
++ * expire at the minimum of half the original time or ten minutes.
++ */
++ warning_limit = MIN(UPTIME_LIMIT_IN_SECONDS/2, TEN_MINUTES_IN_SECONDS);
++ timelimit_timer.expires = jiffies + warning_limit * HZ;
++ timelimit_timer.data = UPTIME_LIMIT_IN_SECONDS - warning_limit;
++
++ add_timer_on(&timelimit_timer, cpumask_first(cpu_online_mask));
++out:
++ return err;
++}
++
++static int __init timelimit_init(void)
++{
++ int err = 0;
++
++ printk(KERN_INFO "Uptime: system uptime restrictions enabled\n");
++
++ /*
++ * Enable the timeout thread for cpu 0 only, assuming that the
++ * uptime limit is non-zero, to protect against any cpu
++ * migration issues.
++ */
++ if (UPTIME_LIMIT_IN_SECONDS)
++ err = timeout_enable(0);
++
++ return err;
++}
++device_initcall(timelimit_init);
+--
+2.10.1
+
diff --git a/meta-tlk/recipes-kernel/linux/linux-intel_%.bbappend b/meta-tlk/recipes-kernel/linux/linux-intel_%.bbappend
new file mode 100644
index 0000000..47c62ef
--- /dev/null
+++ b/meta-tlk/recipes-kernel/linux/linux-intel_%.bbappend
@@ -0,0 +1,3 @@
+FILESEXTRAPATHS_prepend := "${THISDIR}/files:"
+SRC_URI_append = " file://time-limited-kernel.cfg \
+ file://uptime-allow-the-optional-limiting-of-kernel-runtime.patch"
--
2.5.5
More information about the meta-intel
mailing list