---

events.h

Go to the documentation of this file.

/* (c) 2003 Technische Universitaet Dresden
 * This file is part of DROPS, which is distributed under the terms of the
 * GNU General Public License 2. Please see the COPYING file for details.
 */
#ifndef __LIBEVENTS_H
#define __LIBEVENTS_H

#include <l4/sys/compiler.h>
#include <l4/sys/l4int.h>
#include <l4/sys/types.h>


EXTERN_C_BEGIN

/* name used for registering at names server */
#define L4EVENTS_SERVER_NAME      "event_server"


/*****************************************************************************/
/*****************************************************************************/
#define L4EVENTS_OK       0

#define L4EVENTS_WARNING_TASK_REGISTERED  0xf1

#define L4EVENTS_WARNING_TASK_NOT_REGISTERED  0xf2

#define L4EVENTS_WARNING_EVENTS_DELETED   0xf3

#define L4EVENTS_WARNING_EVENTTYP_NOT_REGISTERED 0xf4

#define L4EVENTS_WARNING_NO_EVENT_TO_RECEIVE  0xf5

#define L4EVENTS_WARNING_EVENT_PENDING    0xf6

#define L4EVENTS_WARNING_INVALID_EVENTNR  0xf7

#define L4EVENTS_ERROR_INTERNAL     0xf8

#define L4EVENTS_ERROR_IPC      0xf9

#define L4EVENTS_ERROR_TIMEOUT      0xfa

#define L4EVENTS_ERROR_INVALID_COMMAND    0xfb

#define L4EVENTS_ERROR_OTHER      0xfc

#define L4EVENTS_RECV_OTHER     0xfd

#define L4EVENTS_ERROR_NOT_EXISTS               0xfe

#define L4EVENTS_ERRSTRINGS_DEFINE          \
  { L4EVENTS_WARNING_TASK_REGISTERED,         \
    "EVENTS: Task is already registered" },       \
  { L4EVENTS_WARNING_TASK_NOT_REGISTERED,       \
    "EVENTS: Task is not registered" } ,        \
  { L4EVENTS_WARNING_EVENTS_DELETED,          \
    "EVENTS: Task lost pending events deleted during unregister" }, \
  { L4EVENTS_WARNING_EVENTTYP_NOT_REGISTERED,       \
    "EVENTS: There is no registered task for this channel" },   \
  { L4EVENTS_WARNING_NO_EVENT_TO_RECEIVE,       \
    "EVENTS: No event to receive" },          \
  { L4EVENTS_WARNING_EVENT_PENDING,         \
    "EVENTS: Some registered task has not received this event" }, \
  { L4EVENTS_WARNING_INVALID_EVENTNR,         \
    "EVENTS: Acknowledge: Event-number doesn't exist" },    \
  { L4EVENTS_ERROR_INTERNAL,            \
    "EVENTS: Internal server error occured" },        \
  { L4EVENTS_ERROR_IPC,             \
    "EVENTS: IPC error occured" },          \
  { L4EVENTS_ERROR_TIMEOUT,           \
    "EVENTS: IPC timeout occured" },          \
  { L4EVENTS_ERROR_INVALID_COMMAND,         \
    "EVENTS: Unknown command was sent " },        \
  { L4EVENTS_ERROR_OTHER,           \
    "EVENTS: Undefined error occured" },        \
  { L4EVENTS_RECV_OTHER,            \
    "EVENTS: Unknown server replied to open wait" }

/****************************************************************************
 * \anchor receive and send options
 * 
 ****************************************************************************/

#define L4EVENTS_ASYNC    1

#define L4EVENTS_SEND_ACK 2

#define L4EVENTS_RECV_ACK 4

#define L4EVENTS_GIVE_ACK 8

#define L4EVENTS_RECV_SHORT 16

typedef l4_uint16_t l4events_ch_t;

#define L4EVENTS_NO_CHANNEL 0

#define L4EVENTS_EXIT_CHANNEL 1

#define L4EVENTS_MAX_BUFFER_SIZE  60

#define L4EVENTS_MAX_PRIORITY 15

/*****************************************************************************/
/*****************************************************************************/
typedef struct {
  int len;        
  char  str[L4EVENTS_MAX_BUFFER_SIZE];  
} l4events_event_t;

typedef l4_umword_t l4events_nr_t;

typedef l4_int8_t l4events_pr_t;

#define L4EVENTS_NO_NR  0

/*****************************************************************************/
/*****************************************************************************/
L4_CV int
l4events_init(void);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_register(const l4events_ch_t event_ch, 
          const l4events_pr_t priority);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_unregister(const l4events_ch_t event_ch);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_unregister_all(void);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_send(const l4events_ch_t event_ch, 
                  l4events_event_t *event,
              l4events_nr_t *event_nr,
        const int opt);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_receive(l4events_ch_t *event_ch, 
         l4events_event_t *event,
     l4events_nr_t *event_nr,
     l4_timeout_t timeout,
     const int opt);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_give_ack_and_receive(l4events_ch_t *event_ch,
        l4events_event_t *event,
        l4events_nr_t *event_nr,
        l4_timeout_t timeout,
        const int opt);

/*****************************************************************************/
/*****************************************************************************/
L4_CV int
l4events_dump(void);

typedef L4_CV void (*l4events_recv_function_t)(l4events_ch_t, l4events_event_t *);

/*****************************************************************************/
/*****************************************************************************/
L4_CV void
l4events_wait(int threadno, l4events_ch_t event_ch,
        l4events_recv_function_t function);


/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_get_ack(l4events_nr_t *event_nr, l4_timeout_t timeout);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_get_ack_open(l4events_nr_t *event_nr, l4_threadid_t *id,
              l4_umword_t *w1, l4_umword_t *w2, l4_timeout_t timeout);

/*****************************************************************************/
/*****************************************************************************/
L4_CV long
l4events_give_ack(l4events_nr_t event_nr);

asm(".globl l4events_err_strings_sym; .type l4events_err_strings_sym,%object");

EXTERN_C_END

#endif

---