rres_hooks.c

Go to the documentation of this file.

/*
 * Copyright (C) 2002 Luca Abeni, 2003 Luca Marzario
 * This is Free Software; see GPL.txt for details
 */

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

#ifdef PROF_RRES_HOOKS
#  define QOS_PROFILE
#endif
#include "qos_prof.h"
#include "qos_list.h"
#include "qos_func.h"

#include "kal_generic.h"
#include "rres_interface.h"
#include "rres_kpi_protected.h"
#include "rres.h"
#include "rres_dispatch.h"

#include "rres_time.h"

#ifdef RRES_DISABLE_ACTIVATIONS
#  warning "Servers activation counting, along with block/stop hook pairs, are disabled"
#endif

#ifndef RRES_DISABLE_ACTIVATIONS

qos_func_define(void, rres_unblock_hook, kal_task_t *t, long old_state) {
  unsigned long flags;
  prof_vars;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  prof_func();
  qos_chk_ok(rres_on_task_unblock(t));
  prof_end();
  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);
}

qos_func_define(void, rres_block_hook, kal_task_t *t) {
  unsigned long flags;
  prof_vars;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  prof_func();
  rres_on_task_block(t);
  prof_end();
  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);
}

qos_func_define(void, rres_stop_hook, kal_task_t *t) {
#ifdef RRES_DISPATCH_NEW
  qos_log_debug("Stop hook");
  rres_block_hook(t);
#else
  qos_log_debug("Stop hook ignored");
#endif
}

qos_func_define(void, rres_continue_hook, kal_task_t *t, long old_state) {
#ifdef RRES_DISPATCH_NEW
  qos_log_debug("Continue hook");
  rres_unblock_hook(t, old_state);
#else
  qos_log_debug("Continue hook ignored");
#endif
}

#else /* RRES_DISABLE_ACTIVATIONS */

void rres_unblock_hook(kal_task_t *t, long old_state) {
}

void rres_block_hook(kal_task_t *t) {
}

void rres_stop_hook(kal_task_t *t) {
}

void rres_continue_hook(kal_task_t *t, long old_state) {
}

#endif /* RRES_DISABLE_ACTIVATIONS */

qos_func_define(void, rres_fork_hook, kal_task_t *t, kal_task_t *prev) {
  server_t* srv;
  unsigned long flags;
  prof_vars;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  prof_func();
  srv = rres_find_by_task(prev);
  if (srv != NULL) {
    qos_log_debug("(%d), t->private_data: %p", kal_task_get_id(t), kal_task_get_data(t));
    /* This is needed by rres_attach_to_server(), as fork() copied the private_data field as well. */
    //task_unlink_data(t); // not needed anymore with new fork_hook
    qos_chk_ok(rres_attach_task(srv, t));
  }
  prof_end();
  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);
}

qos_func_define(void, rres_cleanup_hook, kal_task_t *t) {
  server_t* srv;
  unsigned long flags;
  prof_vars;

  kal_spin_lock_irqsave(rres_get_spinlock(), &flags);
  prof_func();
  srv = rres_find_by_task(t);
  if (srv != NULL) {
    rres_sample_time();
    qos_chk_ok_do(rres_detach_task_nosched(srv, t), goto err);
    rres_schedule();
    qos_chk_do((! rres_empty(srv)) || (! rres_has_ready_tasks(srv)), goto err);
    qos_chk_do((! rres_empty(srv)) || (! rres_running(srv)), goto err);
    rres_check_destroy(srv);
    srv = NULL; // DO NOT USE 'srv' VAR FROM HERE ON
    // No need to rres_schedule() again
  }
 err:
  prof_end();
  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);
}

qos_func_define(void, set_gensched_hooks, void) {
  block_hook = rres_block_hook;
  unblock_hook = rres_unblock_hook;
  stop_hook = rres_stop_hook;
  continue_hook = rres_continue_hook;
  fork_hook = rres_fork_hook;
  cleanup_hook = rres_cleanup_hook;
//  deactivate_hook = deactivate_hook_handler;
//  activate_hook = activate_hook_handler;
}

qos_func_define(int, check_gensched_hooks, void) {
  return (
    (block_hook == NULL)
    && (unblock_hook == NULL)
    && (stop_hook == NULL)
    && (continue_hook == NULL)
    && (fork_hook == NULL)
    && (cleanup_hook == NULL)
  );
}

qos_func_define(void, unset_gensched_hooks, void) {
  block_hook = NULL;
  unblock_hook = NULL;
  stop_hook = NULL;
  continue_hook = NULL;
  fork_hook = NULL;
  cleanup_hook = NULL;
//  deactivate_hook = NULL;
//  activate_hook = NULL;
}

#if 0

void switch_hook_handler(kal_task_t *prev, kal_task_t *next ) {
  unsigned long flags;
  qres_clock_t old_sched_time = sched_time;
  server_t *srv;

  spin_lock_irqsave(rres_get_spinlock(), &flags);
  rres_sample_time();
  qos_log_debug("- %6ld, + %6ld", prev->pid, next->pid);
  qos_log_state_simple(prev);
  qos_log_state_simple(next);
  srv = rres_find_by_task(next);
  if (srv && rres_running(srv))
    qos_log_debug("!%d", next->pid);
  kal_spin_unlock_irqrestore(rres_get_spinlock(), &flags);
}

void activate_hook_handler(kal_task_t *p, void *rq) {
  qos_log_state_simple(p);
}
void deactivate_hook_handler(kal_task_t *p, void *rq) {
  qos_log_state_simple(p);
}
#endif /* #if 0 */

---