4 files changed, 112 insertions, 152 deletions

diff --git a/bin/rt_launch.c b/bin/rt_launch.c
index 5e29893..c468b68 100644
--- a/bin/rt_launch.c
+++ b/bin/rt_launch.c
@@ -8,64 +8,63 @@
 #include "litmus.h"
 #include "common.h"
 
-typedef struct {
-        int  wait;
-        char * exec_path;
-        char ** argv;
-} startup_info_t;
-
-
-int launch(void *task_info_p) {
-        startup_info_t *info = (startup_info_t*) task_info_p;
-        int ret;
-        if (info->wait) {
-                ret = wait_for_ts_release();
-                if (ret != 0)
-                        perror("wait_for_ts_release()");
-        }
-        ret = execvp(info->exec_path, info->argv);
-        perror("execv failed");
-        return ret;
-}
+const char *usage_msg =
+        "Usage: rt_launch OPTIONS wcet period program [arg1 arg2 ...]\n"
+        "    -w                wait for synchronous release\n"
+        "    -v                verbose (prints PID)\n"
+        "    -p CPU            physical partition or cluster to assign to\n"
+        "    -r VCPU           virtual CPU to attach to (irrelevant to most plugins)\n"
+        "    -d DEADLINE       relative deadline, implicit by default (in ms)\n"
+        "    -o OFFSET         offset (also known as phase), zero by default (in ms)\n"
+        "    -q PRIORITY       priority to use (ignored by EDF plugins, highest=1, lowest=511)\n"
+        "    -c be|srt|hrt     task class (best-effort, soft real-time, hard real-time)\n"
+        "    -e                turn off budget enforcement (DANGEROUS: can result in lockup)\n"
+        "    wcet, period      reservation parameters (in ms)\n"
+        "    program           path to the binary to be launched\n"
+        "\n";
 
 void usage(char *error) {
-        fprintf(stderr, "%s\nUsage: rt_launch [-w][-v][-p partition/cluster [-z cluster size]][-q prio][-c hrt | srt | be] wcet period program [arg1 arg2 ...]\n"
-                        "\t-w\tSynchronous release\n"
-                        "\t-v\tVerbose\n"
-                        "\t-p\tpartition or cluster\n"
-                        "\t-z\tsize of cluster (default = 1 for partitioned)\n"
-                        "\t-c\tClass\n"
-                        "\twcet, period in ms\n"
-                        "\tprogram to be launched\n",
-                        error);
+        fprintf(stderr, "%s\n%s", error, usage_msg);
         exit(1);
 }
 
+#define OPTSTR "wp:q:c:er:b:o:d:vh"
 
-#define OPTSTR "p:c:vwq:"
-
-int main(int argc, char** argv) 
+int main(int argc, char** argv)
 {
-        int ret;
+        int ret, opt;
         lt_t wcet;
         lt_t period;
-        int migrate = 0;
-        int cluster = 0;
-        int opt;
-        int verbose = 0;
-        int wait = 0;
-        startup_info_t info;
-        task_class_t class = RT_CLASS_HARD;
-        unsigned int priority = LITMUS_LOWEST_PRIORITY;
+        lt_t offset;
+        lt_t deadline;
+        double wcet_ms, period_ms, offset_ms, deadline_ms;
+        unsigned int priority;
+        int migrate;
+        int cluster;
+        int reservation;
+        int wait;
+        int want_enforcement;
+        int verbose;
+        task_class_t class;
+        struct rt_task param;
+
+        /* Reasonable defaults */
+        verbose = 0;
+        offset_ms = 0;
+        deadline_ms = 0;
+        priority = LITMUS_LOWEST_PRIORITY;
+        want_enforcement = 1; /* safety: default to enforcement */
+        wait = 0;  /* don't wait for task system release */
+        class = RT_CLASS_SOFT; /* ignored by most plugins */
+        migrate = 0; /* assume global unless -p is specified */
+        cluster = -1; /* where to migrate to, invalid by default */
+        reservation = -1; /* set if task should attach to virtual CPU */
 
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
                 switch (opt) {
                 case 'w':
                         wait = 1;
                         break;
-                case 'v':
-                        verbose = 1;
-                        break;
                 case 'p':
                         cluster = atoi(optarg);
                         migrate = 1;
@@ -80,7 +79,28 @@ int main(int argc, char** argv)
                         if (class == -1)
                                 usage("Unknown task class.");
                         break;
-
+                case 'e':
+                        want_enforcement = 0;
+                        break;
+                case 'r':
+                        reservation = atoi(optarg);
+                        break;
+                case 'o':
+                        offset_ms = atof(optarg);
+                        break;
+                case 'd':
+                        deadline_ms = atof(optarg);
+                        if (!deadline_ms || deadline_ms < 0) {
+                                usage("The relative deadline must be a positive"
+                                        " number.");
+                        }
+                        break;
+                case 'v':
+                        verbose = 1;
+                        break;
+                case 'h':
+                        usage("");
+                        break;
                 case ':':
                         usage("Argument missing.");
                         break;
@@ -95,33 +115,65 @@ int main(int argc, char** argv)
 
         if (argc - optind < 3)
                 usage("Arguments missing.");
-        wcet   = ms2ns(atoi(argv[optind + 0]));
-        period = ms2ns(atoi(argv[optind + 1]));
+
+        wcet_ms   = atof(argv[optind + 0]);
+        period_ms = atof(argv[optind + 1]);
+
+        wcet   = ms2ns(wcet_ms);
+        period = ms2ns(period_ms);
+        offset = ms2ns(offset_ms);
+        deadline = ms2ns(deadline_ms);
         if (wcet <= 0)
-        usage("The worst-case execution time must be a "
-              "positive number.");
+                usage("The worst-case execution time must be a "
+                                "positive number.");
         if (period <= 0)
                 usage("The period must be a positive number.");
         if (wcet > period) {
                 usage("The worst-case execution time must not "
-                      "exceed the period.");
+                                "exceed the period.");
         }
-        info.exec_path = argv[optind + 2];
-        info.argv      = argv + optind + 2;
-        info.wait      = wait;
+
         if (migrate) {
                 ret = be_migrate_to_domain(cluster);
                 if (ret < 0)
-                        bail_out("could not migrate to target partition or cluster");
+                        bail_out("could not migrate to target partition or cluster.");
         }
-        ret = __create_rt_task(launch, &info, cluster, wcet, period,
-                                priority, class);
-
 
+        init_rt_task_param(&param);
+        param.exec_cost = wcet;
+        param.period = period;
+        param.phase = offset;
+        param.relative_deadline = deadline;
+        param.priority = priority;
+        param.cls = class;
+        param.budget_policy = (want_enforcement) ?
+                        PRECISE_ENFORCEMENT : NO_ENFORCEMENT;
+        if (migrate) {
+                if (reservation >= 0)
+                        param.cpu = reservation;
+                else
+                        param.cpu = domain_to_first_cpu(cluster);
+        }
+        ret = set_rt_task_param(gettid(), &param);
         if (ret < 0)
-                bail_out("could not create rt child process");
-        else if (verbose)
-                printf("%d\n", ret);
+                bail_out("could not setup rt task params");
 
-        return 0;
+        init_litmus();
+
+        ret = task_mode(LITMUS_RT_TASK);
+        if (ret != 0)
+                bail_out("could not become RT task");
+
+        if (verbose)
+                printf("%d\n", gettid());
+
+        if (wait) {
+                ret = wait_for_ts_release();
+                if (ret != 0)
+                        bail_out("wait_for_ts_release()");
+        }
+
+        execvp(argv[optind + 2], argv + optind + 2);
+        perror("execv failed");
+        return 1;
 }
diff --git a/include/internal.h b/include/internal.h
index 035440b..354f7dc 100644
--- a/include/internal.h
+++ b/include/internal.h
@@ -3,11 +3,6 @@
 
 /* low level operations, not intended for API use */
 
-/* prepare a real-time task */
-typedef int (*rt_setup_fn_t)(int pid, void* arg);
-int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg,
-                     rt_setup_fn_t setup, void* setup_arg);
-
 #define check(str)       \
         if (ret == -1) { \
                 perror(str); \
diff --git a/include/litmus.h b/include/litmus.h
index 8c54fdc..f99ccec 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -251,35 +251,6 @@ int  init_rt_thread(void);
  */
 void exit_litmus(void);
 
-/* A real-time program. */
-typedef int (*rt_fn_t)(void*);
-
-/**
- * Create a real-time task that enforces exectution budgets
- * @param rt_prog Function pointer to real-time task body
- * @param arg Pointer to arguments to pass to the pointer in rt_prog
- * @param cluster Cluster to schedule this task on. For partitioned scheduling,
- * set to the desired partition. For global scheduling, set to 0
- * @param wcet Worst-Case execution time for this task
- * @param period Period at which this task should be launched
- * @param prio Priority for this task
- */
-int create_rt_task(rt_fn_t rt_prog, void *arg, int cluster,
-                   lt_t wcet, lt_t period, unsigned int prio);
-/**
- * Create a real-time task
- * @param rt_prog Function pointer to real-time task body
- * @param arg Pointer to arguments to pass to the pointer in rt_prog
- * @param cluster Cluster to schedule this task on. For partitioned scheduling,
- * set to the desired partition. For global scheduling, set to 0
- * @param wcet Worst-Case execution time for this task
- * @param period Period at which this task should be launched
- * @param prio Priority for this task
- * @param cls Task class (unused)
- */
-int __create_rt_task(rt_fn_t rt_prog, void *arg, int cluster,
-                     lt_t wcet, lt_t period, unsigned int prio, task_class_t cls);
-
 /*      per-task modes */
 enum rt_task_mode_t {
         BACKGROUND_TASK = 0,
diff --git a/src/task.c b/src/task.c
index cd78aa9..3e3950c 100644
--- a/src/task.c
+++ b/src/task.c
@@ -8,64 +8,6 @@
 #include "litmus.h"
 #include "internal.h"
 
-static void tperrorx(char* msg)
-{
-        fprintf(stderr,
-                "Task %d: %s: %m",
-                gettid(), msg);
-        exit(-1);
-}
-
-/* common launch routine */
-int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, rt_setup_fn_t setup,
-                     void* setup_arg)
-{
-        int ret;
-        int rt_task = fork();
-
-        if (rt_task == 0) {
-                /* we are the real-time task
-                 * launch task and die when it is done
-                 */
-                rt_task = gettid();
-                ret = setup(rt_task, setup_arg);
-                if (ret < 0)
-                        tperrorx("could not setup task parameters");
-                ret = task_mode(LITMUS_RT_TASK);
-                if (ret < 0)
-                        tperrorx("could not become real-time task");
-                exit(rt_prog(rt_arg));
-        }
-
-        return rt_task;
-}
-
-int __create_rt_task(rt_fn_t rt_prog, void *arg, int cluster,
-                lt_t wcet, lt_t period, unsigned int priority, task_class_t class)
-{
-        struct rt_task params;
-        init_rt_task_param(&params);
-        params.cpu       = domain_to_first_cpu(cluster);
-        params.period    = period;
-        params.exec_cost = wcet;
-        params.cls       = class;
-        params.phase     = 0;
-        params.priority = priority;
-        /* enforce budget for tasks that might not use sleep_next_period() */
-        params.budget_policy = QUANTUM_ENFORCEMENT;
-
-        return __launch_rt_task(rt_prog, arg,
-                                (rt_setup_fn_t) set_rt_task_param, &params);
-}
-
-int create_rt_task(rt_fn_t rt_prog, void *arg, int cluster,
-                lt_t wcet, lt_t period, unsigned int prio)
-{
-        return __create_rt_task(rt_prog, arg, cluster, wcet, period,
-                                prio, RT_CLASS_HARD);
-}
-
-
 #define SCHED_NORMAL 0
 
 int task_mode(int mode)