qres.c

Go to the documentation of this file.

#include <linux/aquosa/rres_config.h>
#include "qres_config.h"
#define QOS_DEBUG_LEVEL QRES_MOD_DEBUG_LEVEL
#include <linux/aquosa/qos_debug.h>
#include <linux/posix-timers.h>
#include <linux/time.h>

#ifdef QRES_MOD_PROFILE
#  define QOS_PROFILE
#endif
#include <linux/aquosa/qos_prof.h>

#include "qres_gw_ks.h"
#include "qsup_gw_ks.h"
#include "qres_kpi_protected.h"

#include <linux/aquosa/qos_types.h>
#include <linux/aquosa/qos_memory.h>
#include <linux/aquosa/qos_func.h>
#include <linux/aquosa/rres.h>
#include <linux/aquosa/kal_sched.h>

qos_rv qres_init(void) {
  // compile-time check, run-time error at module insertion
  if (offsetof(qres_server_t, rres) != 0) {
    qos_log_crit("Please, ensure qres_server_t.rres field has a null offset");
    return QOS_E_INTERNAL_ERROR;
  }
  return QOS_OK;
}

qos_rv qres_cleanup(void) {
  server_t *srv;
  struct list_head *tmp, *tmpdel;

  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);

  /* Destroy all servers, including the default one, if configured. */
  for_each_server_safe(srv, tmp, tmpdel) {
    qos_log_debug("Destroying sever %d ", srv->id);
    /* Virtual call to _qres_cleanup_server() */
    qos_chk_ok_ret(qres_destroy_server(qres_find_by_rres(srv)));
    srv = NULL;
  }
  return QOS_OK;
}

static qos_bool_t authorize_for_task(struct task_struct *tsk) {
  return (kal_task_get_uid(kal_task_current()) == 0) ||
         (kal_task_get_uid(kal_task_current()) == kal_task_get_uid(tsk));
}

static qos_bool_t authorize_for_server(qres_server_t *qres) {
  return (kal_task_get_uid(kal_task_current()) == 0) ||
         (kal_task_get_uid(kal_task_current()) == qres_get_owner_uid(qres));
}

qos_func_define(qos_rv, qres_create_server, qres_params_t *param, qres_sid_t *p_sid) {
  qres_server_t *qres;
  qos_rv rv;

  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  qos_log_debug("q=" QRES_TIME_FMT ", q_min=" QRES_TIME_FMT ", p=" QRES_TIME_FMT ", flags=%d",
      param->Q, param->Q_min, param->P, param->flags);
  qres = qos_create(qres_server_t);
  qos_chk_rv(qres != NULL, QOS_E_NO_MEMORY);
  rv = qres_init_server(qres, param);
  if (rv != QOS_OK) {
    qos_free(qres);
    qos_log_info("qres_init_server failed: %s", qos_strerror(rv));
    return rv;
  }
  *p_sid = rres_get_sid(&qres->rres);
  return QOS_OK;
}

/* TODO: Avoid admission control by RRES without going through all existing servers */
void qres_update_bandwidths(void) {
  struct list_head *tmp;
  server_t *srv;
  for_each_server(srv, tmp) {
    qres_time_t q = bw2Q(rres_get_bandwidth(srv), rres_get_period(srv));
    rres_set_budget(srv, q);
  }
}

qos_func_define(qos_rv, qres_init_server, qres_server_t *qres, qres_params_t *param) {
  qos_rv rv;
  qres_time_t approved_Q;
  qos_bw_t bw_min;
  qos_bw_t bw_req;
  kal_uid_t uid;
  kal_gid_t gid;

  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  qos_log_debug("(Q, P): (" QRES_TIME_FMT ", " QRES_TIME_FMT ")", param->Q, param->P);
  if (param->P < MIN_SRV_PERIOD || param->Q > param->P)
    return QOS_E_INVALID_PARAM;

  if (param->Q < MIN_SRV_MAX_BUDGET) {
//    param->Q = MIN_SRV_MAX_BUDGET;
    return QOS_E_INVALID_PARAM;
  }

  /* Round the minimum required bandwidth to the lowest >= value
   * available due to qos_bw_t granularity
   */
  bw_min = r2bw_ceil(param->Q_min, param->P);

  /* Round the requested values according to the qos_bw_t granularity */
  param->Q_min = bw2Q(bw_min, param->P);
  param->Q = bw2Q(r2bw_ceil(param->Q, param->P), param->P);
  qos_log_debug("Rounded (Q, Q_min, P): (" QRES_TIME_FMT ", " QRES_TIME_FMT ", " QRES_TIME_FMT ")", param->Q, param->Q_min, param->P);

  uid = kal_task_get_uid(kal_task_current());
  gid = kal_task_get_gid(kal_task_current());

#ifdef QRES_ENABLE_QSUP
  /* First, check if request of guaranteed bw min respects constraints
   * for the requesting user (according to its effective uid/guid), and
   * create RRES server (i.e. perform admission control) based on this
   * value.
   */
  if (param->flags & QOS_F_DEFAULT) {
    if (uid != 0 && uid != QSUP_DEFAULT_SRV_UID && gid != QSUP_DEFAULT_SRV_GID)
      return QOS_E_UNAUTHORIZED;
  }
  qos_chk_ok_ret(qsup_init_server(&qres->qsup, kal_task_get_uid(kal_task_current()),
                                  kal_task_get_gid(kal_task_current()), param));

  /* Then, set the actual request (may be < = > than min guaranteed)    */
  bw_req = r2bw(param->Q, param->P);
  qos_log_debug("Setting required bw to " QOS_BW_FMT, bw_req);
  rv = qsup_set_required_bw(&qres->qsup, bw_req);
  if (rv != QOS_OK) {
    qos_log_info("qsup_set_required_bw() failed: %s", qos_strerror(rv));
    qsup_cleanup_server(&qres->qsup);
    return rv;
  }

  approved_Q = bw2Q(qsup_get_approved_bw(&qres->qsup), param->P);

#else
  if ((param->flags & QOS_F_DEFAULT) && (uid != 0))
    return QOS_E_UNAUTHORIZED;
  approved_Q = param->Q;
#endif

  qos_log_debug("Required=" QRES_TIME_FMT ", Approved=" QRES_TIME_FMT, param->Q, approved_Q);

  // New incomplete server not yet enqueued, so it is safe to loop all servers.
  // All servers get possibly reduced bandwidths due to the presence of the new server.
  qres_update_bandwidths();

  rv = rres_init_server(&qres->rres, approved_Q,
                        param->P, param->flags);
  if (rv != QOS_OK) {
    qos_log_info("rres_init_server() failed: %s", qos_strerror(rv));
#ifdef QRES_ENABLE_QSUP
    qsup_cleanup_server(&qres->qsup);
#endif
    // New incomplete server was not enqueued, so it is safe to loop all servers.
    // All servers have their bandwidths back like before creation of this server.
    qres_update_bandwidths();
    return rv;
  }

  qres->owner_uid = uid;
  qres->owner_gid = gid;

  qres->params = *param;

  /* Override parent class vtable */
  qres->rres.cleanup = &_qres_cleanup_server;
  qres->rres.get_bandwidth = &_qres_get_bandwidth;

  return QOS_OK;
}

qos_func_define(qos_rv, qres_destroy_server, qres_server_t *qres) {
  struct task_struct *task;
  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  while ((task = rres_any_ready_task(&qres->rres)) != NULL) {
    qos_chk_ok_ret(rres_detach_task(&qres->rres, task));
  }
  while ((task = rres_any_blocked_task(&qres->rres)) != NULL) {
    qos_chk_ok_ret(rres_detach_task(&qres->rres, task));
  }
  qos_chk_ok_ret(rres_destroy_server(&qres->rres));
  qres = NULL; // Don't use qres pointer from here on
  // No need to rres_schedule() nor to call destructor nor to deallocate -- already done by destroy_server
  return QOS_OK;
}

qos_func_define(qos_rv, _qres_cleanup_server, server_t *rres) {
  qres_server_t *qres = qres_find_by_rres(rres);

  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  if (! authorize_for_server(qres))
    return QOS_E_UNAUTHORIZED;

  /* First, destroy child extensions keeping overridden vtable */

#ifdef QRES_ENABLE_QSUP
  qos_chk_ok_ret(qsup_cleanup_server(&qres->qsup));
#endif

  /* Then, reset original parent class vtable   */

  qres->rres.cleanup = &_rres_cleanup_server;
  qres->rres.get_bandwidth = &_rres_get_bandwidth;

  /* Finally, destroy parent class              */
  qos_chk_ok_ret(_rres_cleanup_server(&qres->rres));
  return QOS_OK;
}

qos_bw_t _qres_get_bandwidth(server_t *srv) {
  qres_server_t *qres = qres_find_by_rres(srv);
  /* r2bw works with clocks too, as long as all in/out params fit into an unsigned long */
#ifdef QRES_ENABLE_QSUP
  return qsup_get_approved_bw(&qres->qsup);
#else
  return _rres_get_bandwidth(&qres->rres);
#endif
}

qos_func_define(qos_rv, qres_attach_task, qres_server_t *qres, struct task_struct *tsk) {
  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  if ((! authorize_for_task(tsk)) || (! authorize_for_server(qres)))
    return QOS_E_UNAUTHORIZED;
  qos_chk_ok_ret(rres_attach_task(&qres->rres, tsk));

  /* Dynamic reclamation is automatic here, no need to explicitly       *
   * require the QSUP_DYNAMIC_RECLAIM switch !                          */
  if (rres_has_ready_tasks(&qres->rres)) {
    qsup_set_required_bw(&qres->qsup, r2bw(qres->params.Q, qres->params.P));
  }

  return QOS_OK;
}

qos_func_define(qos_rv, qres_detach_task, qres_server_t *qres, struct task_struct *tsk) {
  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  if (qres == NULL)
    return QOS_E_NOT_FOUND;
  if ((! authorize_for_task(tsk)) || (! authorize_for_server(qres)))
    return QOS_E_UNAUTHORIZED;
  qos_chk_ok_ret(rres_detach_task(&qres->rres, tsk));

  /* Dynamic reclamation is automatic here, no need to explicitly       *
   * require the QSUP_DYNAMIC_RECLAIM switch !                          */
  if (! rres_has_ready_tasks(&qres->rres)) {
    qsup_set_required_bw(&qres->qsup, 0);
  }

  qos_chk_ok_ret(rres_check_destroy(&qres->rres));
  qres = NULL; // DO NOT USE qres POINTER, FROM HERE ON
  return QOS_OK;
}

qos_func_define(qos_rv, qres_set_params, qres_server_t *qres, qres_params_t *param) {
  qres_time_t approved_Q;

  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  qos_log_debug("Q=" QRES_TIME_FMT "  Q_min=" QRES_TIME_FMT "  P=" QRES_TIME_FMT,
                param->Q, param->Q_min, param->P);

  if (! authorize_for_server(qres))
    return(QOS_E_UNAUTHORIZED);

  if (param->P < MIN_SRV_PERIOD || param->Q > param->P)
    return QOS_E_INVALID_PARAM;

  if (param->Q < MIN_SRV_MAX_BUDGET)
    return QOS_E_INVALID_PARAM;

  if (param->flags != qres->params.flags)
    return QOS_E_UNIMPLEMENTED;

  /* Round the requested values according to the qos_bw_t granularity */
  param->Q_min = bw2Q(r2bw_ceil(param->Q_min, param->P), param->P);
  param->Q = bw2Q(r2bw_ceil(param->Q, param->P), param->P);
  qos_log_debug("Rounded (Q, Q_min, P): (" QRES_TIME_FMT ", " QRES_TIME_FMT ", " QRES_TIME_FMT ")", param->Q, param->Q_min, param->P);

#ifdef QRES_ENABLE_QSUP
  if (param->Q_min != qres->params.Q_min
      || param->P != qres->params.P) {
    qos_chk_ok_ret(qsup_cleanup_server(&qres->qsup));
    if (qsup_init_server(&qres->qsup, qres->owner_uid, qres->owner_gid, param) != QOS_OK)
      qos_chk_ok_ret(qsup_init_server(&qres->qsup, qres->owner_uid, qres->owner_gid, &qres->params));
  }
  qos_chk_ok_ret(qsup_set_required_bw(&qres->qsup, r2bw(param->Q, param->P)));
  approved_Q = bw2Q(qsup_get_approved_bw(&qres->qsup), param->P);
#else
  approved_Q = param->Q;
#endif
  qos_log_debug("Required=" QRES_TIME_FMT ", Approved=" QRES_TIME_FMT, param->Q, approved_Q);
  qos_chk_ok_ret(rres_set_params(&qres->rres, approved_Q, param->P));
  qres->params = *param;

  return QOS_OK;
}

qos_func_define(qos_rv, qres_get_params, qres_server_t *qres, qres_params_t *params) {
  qos_chk_do(kal_atomic(), return QOS_E_INTERNAL_ERROR);
  *params = qres->params;
  return QOS_OK;
}

qos_func_define(qres_time_t, qres_get_curr_budget, qres_server_t *qres) {
  return rres_get_curr_budget(&qres->rres);
}

qos_func_define(qres_time_t, qres_get_next_budget, qres_server_t *qres) {
  return bw2Q(rres_get_current_bandwidth(&qres->rres), qres->params.P);
}

qos_func_define(qres_time_t, qres_get_appr_budget, qres_server_t *qres) {
  return bw2Q(rres_get_bandwidth(&qres->rres), qres->params.P);
}

qos_func_define(qos_rv, qres_get_deadline, qres_server_t *qres, struct timespec *p_deadline) {
  return rres_get_deadline(&qres->rres, p_deadline);
}

qos_func_define(qos_rv, qres_get_exec_abs_time, qres_server_t *qres,
              qres_time_t *exec_time, qres_atime_t *abs_time) {
  *exec_time = rres_get_exec_time(&qres->rres);
  *abs_time = kal_time2usec(kal_time_now());
  return QOS_OK;
}

kal_uid_t qres_get_owner_uid(qres_server_t* qres) {
  return qres->owner_uid;
}
EXPORT_SYMBOL_GPL(qres_get_owner_uid);

kal_gid_t qres_get_owner_gid(qres_server_t* qres) {
  return qres->owner_gid;
}
EXPORT_SYMBOL_GPL(qres_get_owner_gid);

EXPORT_SYMBOL_GPL(qres_create_server);
EXPORT_SYMBOL_GPL(qres_destroy_server);
EXPORT_SYMBOL_GPL(qres_attach_task);
EXPORT_SYMBOL_GPL(qres_detach_task);
EXPORT_SYMBOL_GPL(qres_set_params);
EXPORT_SYMBOL_GPL(qres_get_params);
//EXPORT_SYMBOL_GPL(qres_get_exec_time);
EXPORT_SYMBOL_GPL(qres_get_exec_abs_time);
EXPORT_SYMBOL_GPL(qres_get_deadline);

/* Export protected symbols */
EXPORT_SYMBOL_GPL(_qres_get_bandwidth);
EXPORT_SYMBOL_GPL(_qres_cleanup_server);

---