rres_proc_fs.c

Go to the documentation of this file.

#include "rres_config.h"
#define QOS_DEBUG_LEVEL RRES_MOD_DEBUG_LEVEL
#include "qos_debug.h"

#ifdef CONFIG_OC_RRES_PROC
//#include <linux/autoconf.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/ctype.h> //for numeric conversion
#include <stdarg.h>

#include "qos_list.h"

#include "rres_proc_fs.h"
#include "rres.h"
#include "rres_time.h"
#include "rres_interface.h"
#include "rres_kpi_protected.h"

extern struct proc_dir_entry proc_root;           
struct proc_dir_entry *aquosa_proc_root = NULL;   
struct proc_dir_entry *qres_proc_root = NULL;     
EXPORT_SYMBOL_GPL(qres_proc_root);

static int rres_read_tasks(char *page, char **start, off_t off, int count,
                           int *eof, void *data) {
  PROC_PRINT_VARS;
  int i;
  kal_irq_state flags;
  kal_time_t curr_time;
  kal_task_t *t;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  curr_time = kal_time_now();
  PROC_PRINT("time: " KAL_TIME_FMT "\n", KAL_TIME_FMT_ARG(curr_time));
  i=0;
  /* @todo Warning: this spinlock introduce a high latency !!! */
  if (!list_empty(&server_list)) {
    server_t *srv;
    struct list_head * tmp_list;

    PROC_PRINT("%6s %6s %8s %6s %8s %12s %6s\n", 
        "srvid |", "pid |", "policy |", "rt_prio |", "state |", "pointer |", "stp");
    for_each_server(srv, tmp_list) {
      struct list_head *h;
      if (rres_empty(srv)) {
        PROC_PRINT("%6d Empty\n", srv->id);
        continue;
      }

      for_each_ready_task_in_server(srv, t, h) {
        struct task_list *tl = rres_find_task_list(t);
        PROC_PRINT("%6d %6d %8u %6u %8li %12p",
                   srv->id, t->pid, t->policy, t->rt_priority, t->state, rres_find_by_task(t));
        if (tl != NULL) {
          PROC_PRINT(" %6d", tl->is_stopped);
        }
        PROC_PRINT("\n");
      }
      for_each_blocked_task_in_server(srv, t, h) {
        struct task_list *tl = rres_find_task_list(t);
        PROC_PRINT("%6d %6d %8u %6u %8li %12p",
                   srv->id, t->pid, t->policy, t->rt_priority, t->state, rres_find_by_task(t));
        if (tl != NULL) {
          PROC_PRINT(" %6d", tl->is_stopped);
        }
        PROC_PRINT("\n");
      }
    }
  } else {
    PROC_PRINT("No server in the system\n");
  }
  PROC_PRINT_DONE;

  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);

  PROC_PRINT_END;
}

static int rres_read_sched(char *page, char **start, off_t off, int count,
                           int *eof, void *data) {
  int i;
  struct list_head *tmp_list;
  server_t *srv;
  kal_irq_state flags;
  unsigned long period, max_budg, exec_time;
  long long int current_budg;
  kal_time_t curr_time;
  PROC_PRINT_VARS;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  curr_time = kal_time_now();
  PROC_PRINT("time: " KAL_TIME_FMT "\n", KAL_TIME_FMT_ARG(curr_time));
  PROC_PRINT("reserved bandwidth %lu%%\n", U_tot * 100 / MAX_BW);
  i=0;
  if (! list_empty(&server_list)) {
    PROC_PRINT(" " "%6s %8s %8s %10s %12s %10s %12s %4s %4s %4s\n", 
        "srv|", "period|", "max_bdg|", "cur_bdg|", "deadline|", "diff|", "exec time|", "rdy|", "emp|", "flags");
    /* @todo Warning: this loop under spinlock introduces an arbitrarily high latency !!! */
    for_each_server(srv, tmp_list) {
      period = srv->period_us;
      max_budg = bw2Q(rres_get_bandwidth(srv), srv->period_us);
      current_budg = kal_time2usec(srv->c);
      exec_time = rres_get_exec_time(srv);
      PROC_PRINT("%6d %8lu %8lu %10ld %5lu.%6lu %10ld %12lu %4d %4d %04x\n", 
        srv->id,
        clock2us(period),
        clock2us(max_budg),
        clock2us(current_budg),
        (unsigned long) kal_time_get_sec(srv->deadline), (unsigned long) kal_time_get_usec(srv->deadline),
        (long int) kal_time2usec(kal_time_sub(srv->deadline, curr_time)),
        exec_time,
        rres_has_ready_tasks(srv), rres_empty(srv),
        srv->flags
      );
    }
  } else {
    PROC_PRINT("No server in the system\n");
  }

  PROC_PRINT_DONE;

  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);

  PROC_PRINT_END;
}  /* End function - rres_read_sched */

/* @todo (low) complete this function */
static int rres_read_modinfo(char *page, char **start, off_t off, int count,
                             int *eof, void *data) {
  PROC_PRINT_VARS;
  PROC_PRINT("Enabled options for AQuoSA RRES:\n\n");

  PROC_PRINT("Multitasking servers:\t");
  PROC_PRINT("on\n");

  PROC_PRINT("Precise allocation\t");
  PROC_PRINT("on\n");

  PROC_PRINT("High resoluton timers\t");
#ifdef KAL_USE_HRTIMER
  PROC_PRINT("on\n");
#else
  PROC_PRINT("off\n");
#endif

  PROC_PRINT("Heap-ordered deadlines\t");
#ifdef RRES_USE_HEAP
  PROC_PRINT("on\n");
#else
  PROC_PRINT("off\n");
#endif

  PROC_PRINT("Task dispatching mech.\t");
#ifdef RRES_DISPATCH_NEW
  PROC_PRINT("activate_local/deactivate_local\n");
#elif defined(RRES_DISPATCH_SIG)
  PROC_PRINT("sig_send(SIG_STOP)/sig_send(SIG_CONT)\n");
#else
  PROC_PRINT("GENSCHED_DISABLED task state\n");
#endif

  PROC_PRINT("Default Linux server\t");
#ifdef CONFIG_RRES_DEFAULT_SRV
  PROC_PRINT("on\n");
#else
  PROC_PRINT("off\n");
#endif

  PROC_PRINT("Debugging level\t\t");
#ifdef RRES_MOD_DEBUG_LEVEL
  PROC_PRINT("%d\n", RRES_MOD_DEBUG_LEVEL);
#else
  PROC_PRINT("off\n");
#endif

  PROC_PRINT("Paranoid checks\t\t");
  if (RRES_PARANOID)
    PROC_PRINT("on\n");
  else
    PROC_PRINT("off\n");

  PROC_PRINT("\n");
  PROC_PRINT_DONE;

  PROC_PRINT_END;
}  /* End function - rres_read_param */

int rres_proc_register(void) {
  struct proc_dir_entry *proc_sched_ent;
  struct proc_dir_entry *proc_tasks_ent;
  struct proc_dir_entry *proc_modinfo_ent;

  aquosa_proc_root = create_proc_entry(OC_PROC_ROOT, S_IFDIR, 0);
  /* FIXME: it must be done at a higer level */
  if (!aquosa_proc_root) {
    printk("Unable to initialize /proc/" OC_PROC_ROOT "\n");
    return(-1);
  }
  qres_proc_root = create_proc_entry("qres", S_IFDIR,  aquosa_proc_root);
  if (!qres_proc_root) {
    printk("Unable to initialize /proc/" OC_PROC_ROOT "/qres\n");
    return(-1);
  }
  //qres_proc_root->owner = THIS_MODULE;
  proc_sched_ent = create_proc_entry("scheduler", S_IFREG|S_IRUGO|S_IWUSR, qres_proc_root);
  if (!proc_sched_ent) {
    printk("Unable to initialize /proc/" OC_PROC_ROOT "/qres/scheduler\n");
    return(-1);
  }
  proc_sched_ent->read_proc = rres_read_sched;

  proc_tasks_ent = create_proc_entry("tasks", S_IFREG|S_IRUGO|S_IWUSR, qres_proc_root);
  if (!proc_tasks_ent) {
    printk("Unable to initialize /proc/" OC_PROC_ROOT "/qres/tasks\n");
    return(-1);
  }
  proc_tasks_ent->read_proc = rres_read_tasks;
  proc_modinfo_ent = create_proc_entry("modinfo", S_IFREG|S_IRUGO|S_IWUSR, qres_proc_root);
  if (!proc_modinfo_ent) {
    printk("Unable to initialize /proc/" OC_PROC_ROOT "/qres/modinfo\n");
    return(-1);
  }
  proc_modinfo_ent->read_proc = rres_read_modinfo;

  return(0);
}

void rres_proc_unregister(void) {
//  remove_proc_entry("param", qres_proc_root);
  remove_proc_entry("modinfo", qres_proc_root);
  remove_proc_entry("tasks", qres_proc_root);
//  remove_proc_entry("servers", qres_proc_root);
  remove_proc_entry("scheduler", qres_proc_root);
  remove_proc_entry("qres", aquosa_proc_root);
  remove_proc_entry(OC_PROC_ROOT, 0); 
}

#else /* ! CONFIG_OC_RRES_PROC */
int rres_proc_register(void) { return 0; }
void rres_proc_unregister(void) {}
#endif /* CONFIG_OC_RRES_PROC */

---