qmgr_gw_ks.h

Go to the documentation of this file.

#ifndef __QMGR_GW_KS_H__
#define __QMGR_GW_KS_H__

#include <linux/aquosa/qos_kernel_dep.h>

#include <linux/kernel.h>       /* We're doing kernel work */
#include <linux/module.h>       /* Specifically, a module */
#include <asm/uaccess.h>        /* for get_user and put_user */
#include <linux/sched.h>

#include <linux/aquosa/qos_debug.h>
#include <linux/aquosa/qos_types.h>
#include <linux/aquosa/qos_prof.h>

#include <linux/aquosa/qmgr_config.h>
#include <linux/aquosa/qmgr_gw.h>
#include <linux/aquosa/qmgr_base.h>
#include <linux/aquosa/qmgr_params.h>
#include <linux/aquosa/qmgr_time.h>
#include <linux/aquosa/rres_interface.h>

typedef struct {
  qres_server_t qres;
  qmgr_t qmgr;
} qmgr_server_t;

qos_rv qmgr_init_ks(void);

qos_rv qmgr_cleanup_ks(void);

qos_rv qmgr_start_ks(qmgr_params_t *params);
qos_rv qmgr_stop_ks(void);

static inline qmgr_server_t *qmgr_find_by_task(struct task_struct *tsk) {
  server_t *srv = rres_find_by_task(tsk);
  if (srv == NULL)
    return NULL;
  return (qmgr_server_t *) srv;
}

static inline qos_rv qmgr_end_cycle_ks(int skip, qres_time_t *p_sched_error) {
  qos_rv rv;
  struct task_struct *tsk;
  qmgr_server_t *srv;
  qmgr_t *qmgr;
  qos_bw_t new_bw;
  qres_params_t params;

  qos_log_debug("Starting function (skip=%d)", skip);

  tsk = get_current();
  srv = qmgr_find_by_task(tsk);
  if (srv == NULL) {
    qos_log_err("Could not find server");
    return QOS_E_NOSERVER;
  }
  qmgr = &srv->qmgr;

  qos_log_debug("Calling qmgr_ctrl_end_cycle()");
  new_bw = qmgr_ctrl_end_cycle(qmgr->ctrl, skip, p_sched_error);
  qos_log_debug("new_bw=" QOS_BW_FMT, new_bw);
  qos_log_debug("Calling qres_get_params_ks()");
  rv = qres_get_params(&srv->qres, &params);
  if (rv != QOS_OK) {
    qos_log_err("qres_get_params_ks() failed: %s", qos_strerror(rv));
    return rv;
  }
  params.Q = bw2Q(new_bw, params.P);
  qos_log_debug("Calling qres_set_params_ks()");
  rv = qres_set_params(qres_find_by_rres(rres_find_by_task(tsk)), &params);
  if (rv != QOS_OK) {
    qos_log_err("qres_get_params_ks() failed: %s", qos_strerror(rv));
    return rv;
  }

  qos_log_debug("Ending function");
  return QOS_OK;
}

static inline qos_rv qmgr_pause_ks(void) {
  qos_log_debug("Starting qmgr_pause_ks()");
  return QOS_OK;
}

static inline qos_rv qmgr_continue_ks(void) {
  struct task_struct *tsk;
  qmgr_server_t *srv;

  tsk = get_current();
  srv = qmgr_find_by_task(tsk);
  if (srv == NULL) {
    qos_log_err("Could not find server");
    return QOS_E_NOSERVER;
  }

  qmgr_time_init(&srv->qmgr.ctrl->time);

  return QOS_OK;
}

static inline qos_rv qmgr_sync_ks(void) {
  struct task_struct *tsk;
  qmgr_server_t *srv;

  qos_log_debug("Starting function");

  tsk = get_current();
  srv = qmgr_find_by_task(tsk);
  if (srv == 0) {
    qos_log_err("Could not find QMGR descriptor");
    return QOS_E_NOSERVER;
  }

  return qmgr_ctrl_sync(srv->qmgr.ctrl);
}

static inline qos_rv qmgr_get_exec_time_ks(void *param, unsigned long size) {
  struct task_struct *tsk;
  qmgr_server_t *srv;
  qres_time_t exec_time;

  qos_log_debug("Starting function");

  tsk = get_current();
  srv = qmgr_find_by_task(tsk);
  if (srv == 0) {
    qos_log_err("Could not find QMGR descriptor");
    return QOS_E_NOSERVER;
  }

  exec_time = qmgr_time_get_exec(&srv->qmgr.ctrl->time);
  if (copy_to_user(param, &exec_time, sizeof(qres_time_t) != 0))
    return QOS_E_GENERIC;

  return QOS_OK;
}

static inline qos_rv qmgr_get_sched_err_ks(void *param, unsigned long size) {
  struct task_struct *tsk;
  qmgr_server_t *srv;

  qos_log_debug("Starting function");

  tsk = get_current();
  srv = qmgr_find_by_task(tsk);
  if (srv == 0) {
    qos_log_err("Could not find QMGR descriptor");
    return QOS_E_NOSERVER;
  }

  put_user(srv->qmgr.ctrl->old_eps, (qres_time_t *) param);
  return QOS_OK;
}

static inline qos_rv qmgr_gw_ks(qmgr_op_t op, void __user *up_param, unsigned long size) {
  qmgr_params_t qmgr_params;
  qos_rv rv;
  prof_vars;

  prof_func();
  qos_log_debug("Starting qmgr_gw_ks()");
  switch (op) {
  case QMGR_OP_START:
    if (size != sizeof(qmgr_params_t)) {
      qos_log_err("Wrong size");
      rv = QOS_E_INTERNAL_ERROR;
      break;
    }
    if (copy_from_user(&qmgr_params, up_param, sizeof(qmgr_params_t)) != 0)
      rv = QOS_E_GENERIC;
    else
      rv = qmgr_start_ks(&qmgr_params);
    break;
  case QMGR_OP_STOP:
    rv = qmgr_stop_ks();
    break;
  case QMGR_OP_END_CYCLE:
    if (size != sizeof(qres_time_t)) {
      qos_log_err("Wrong size");
      rv = QOS_E_INTERNAL_ERROR;
      break;
    }
    {
      qres_time_t sched_error;
      rv = qmgr_end_cycle_ks(0, &sched_error);
      if (up_param != 0)
        if (copy_to_user(up_param, &sched_error, sizeof(sched_error) != 0))
          rv = QOS_E_GENERIC;
    }
    break;
  case QMGR_OP_END_CYCLE_SKIP:
    {
      qres_time_t sched_error;
      rv = qmgr_end_cycle_ks(1, &sched_error);
      if (up_param != 0)
        if (copy_to_user(up_param, &sched_error, sizeof(sched_error)) != 0)
          rv = QOS_E_GENERIC;
    }
    break;
  case QMGR_OP_PAUSE:
    rv = qmgr_pause_ks();
    break;
  case QMGR_OP_CONTINUE:
    rv = qmgr_continue_ks();
    break;
  case QMGR_OP_SYNC:
    rv = qmgr_sync_ks();
    break;
  case QMGR_OP_GET_EXEC_TIME:
    rv = qmgr_get_exec_time_ks(up_param, size);
    break;
  case QMGR_OP_GET_SCHED_ERR:
    rv = qmgr_get_sched_err_ks(up_param, size);
    break;
  default:
    qos_log_err("Unhandled operation code");
    rv = QOS_E_INTERNAL_ERROR;  /* For debugging purposes */
  }
  prof_end();
  return rv;
}

#endif

---