kumquat-buildroot/package/fusion/fusion.h

278 lines
9.8 KiB
C
Raw Normal View History

2007-08-12 20:19:45 +02:00
#ifndef __LINUX__FUSION_H__
#define __LINUX__FUSION_H__
#include <asm/ioctl.h>
/*
* Fusion Kernel Device API Version
*/
#define FUSION_API_MAJOR 3 /* Increased if backward compatibility is dropped. */
#define FUSION_API_MINOR 2 /* Increased if new features are added. */
/*
* The Fusion ID is a unique identifier for one process consisting of threads.
*/
typedef unsigned long FusionID;
#define FUSION_ID_MASTER 1 /* This is the fusion id of the master (first process). */
/*
* Entering a world
*/
typedef struct {
struct {
int major; /* Must be set to FUSION_API_MAJOR before entering. */
int minor; /* Must be set to FUSION_API_MINOR before entering. */
} api;
FusionID fusion_id; /* Returns the fusion id of the entering process. */
} FusionEnter;
/*
* Forking in world
*/
typedef struct {
FusionID fusion_id; /* Returns the fusion id of the new (forked) fusionee. */
} FusionFork;
/*
* Sending a message
*/
typedef struct {
FusionID fusion_id; /* recipient */
int msg_id; /* optional message identifier */
int msg_size; /* message size, must be greater than zero */
const void *msg_data; /* message data, must not be NULL */
} FusionSendMessage;
/*
* Receiving a message
*/
typedef enum {
FMT_SEND, /* msg_id is an optional custom id */
FMT_CALL, /* msg_id is the call id */
FMT_REACTOR, /* msg_id is the reactor id */
FMT_SHMPOOL /* msg_id is the pool id */
} FusionMessageType;
typedef struct {
FusionMessageType msg_type; /* type (origin) of message */
int msg_id; /* message id (custom id or call/reactor/pool id) */
int msg_size; /* size of the following message data */
/* message data follows */
} FusionReadMessage;
/*
* Dispatching a message via a reactor
*/
typedef struct {
int reactor_id;
int self;
int msg_size; /* message size, must be greater than zero */
const void *msg_data; /* message data, must not be NULL */
} FusionReactorDispatch;
/*
* Calling (synchronous RPC)
*/
typedef struct {
int call_id; /* new call id returned */
void *handler; /* function pointer of handler to install */
void *ctx; /* optional handler context */
} FusionCallNew;
typedef enum {
FCEF_NONE = 0x00000000,
FCEF_ONEWAY = 0x00000001,
FCEF_ALL = 0x00000001
} FusionCallExecFlags;
typedef struct {
int ret_val; /* return value of the call */
int call_id; /* id of the requested call, each call has a fixed owner */
int call_arg; /* optional int argument */
void *call_ptr; /* optional pointer argument (shared memory) */
FusionCallExecFlags flags; /* execution flags */
} FusionCallExecute;
typedef struct {
int call_id; /* id of currently executing call */
int val; /* value to return */
} FusionCallReturn;
typedef struct {
void *handler; /* function pointer of handler to call */
void *ctx; /* optional handler context */
int caller; /* fusion id of the caller or zero if called from Fusion */
int call_arg; /* optional call parameter */
void *call_ptr; /* optional call parameter */
} FusionCallMessage;
/*
* Watching a reference
*
* This information is needed to have a specific call being executed if the
* reference count reaches zero. Currently one watch per reference is allowed.
*
* The call is made by Fusion and therefor has a caller id of zero.
*
*/
typedef struct {
int id; /* id of the reference to watch */
int call_id; /* id of the call to execute */
int call_arg; /* optional call parameter, e.g. the id of a user
space resource associated with that reference */
} FusionRefWatch;
/*
* Inheriting local count from other reference
*/
typedef struct {
int id; /* own reference id */
int from; /* id of the reference to inherit from */
} FusionRefInherit;
/*
* Killing other fusionees (experimental)
*/
typedef struct {
FusionID fusion_id; /* fusionee to kill, zero means all but ourself */
int signal; /* signal to be delivered, e.g. SIGTERM */
int timeout_ms; /* -1 means no timeout, 0 means infinite, otherwise the
max. time to wait until the fusionee(s) terminated */
} FusionKill;
/*
* Shared memory pools
*/
typedef struct {
int max_size; /* Maximum size that this pool will be allowed to grow to. */
int pool_id; /* Returns the new pool id. */
void *addr_base; /* Returns the base of the reserved virtual memory address space. */
} FusionSHMPoolNew;
typedef struct {
int pool_id; /* The id of the pool to attach to. */
void *addr_base; /* Returns the base of the reserved virtual memory address space. */
int size; /* Returns the current size of the pool. */
} FusionSHMPoolAttach;
typedef struct {
int pool_id; /* The id of the pool to notify. */
int size; /* New size of the pool. */
} FusionSHMPoolDispatch;
typedef enum {
FSMT_REMAP, /* Remap the pool due to a change of its size. */
FSMT_UNMAP /* Unmap the pool due to its destruction. */
} FusionSHMPoolMessageType;
typedef struct {
FusionSHMPoolMessageType type; /* Type of the message. */
int size; /* New size of the pool, if type is FSMT_REMAP. */
} FusionSHMPoolMessage;
/*
* Fusion types
*/
typedef enum {
FT_LOUNGE,
FT_MESSAGING,
FT_CALL,
FT_REF,
FT_SKIRMISH,
FT_PROPERTY,
FT_REACTOR,
FT_SHMPOOL
} FusionType;
/*
* Set attributes like 'name' for an entry of the specified type.
*/
#define FUSION_ENTRY_INFO_NAME_LENGTH 24
typedef struct {
FusionType type;
int id;
char name[FUSION_ENTRY_INFO_NAME_LENGTH];
} FusionEntryInfo;
#define FUSION_ENTER _IOR(FT_LOUNGE, 0x00, FusionEnter)
#define FUSION_UNBLOCK _IO (FT_LOUNGE, 0x01)
#define FUSION_KILL _IOW(FT_LOUNGE, 0x02, FusionKill)
#define FUSION_ENTRY_SET_INFO _IOW(FT_LOUNGE, 0x03, FusionEntryInfo)
#define FUSION_ENTRY_GET_INFO _IOW(FT_LOUNGE, 0x04, FusionEntryInfo)
#define FUSION_FORK _IOW(FT_LOUNGE, 0x05, FusionFork)
#define FUSION_SEND_MESSAGE _IOW(FT_MESSAGING, 0x00, FusionSendMessage)
#define FUSION_CALL_NEW _IOW(FT_CALL, 0x00, FusionCallNew)
#define FUSION_CALL_EXECUTE _IOW(FT_CALL, 0x01, FusionCallExecute)
#define FUSION_CALL_RETURN _IOW(FT_CALL, 0x02, FusionCallReturn)
#define FUSION_CALL_DESTROY _IOW(FT_CALL, 0x03, int)
#define FUSION_REF_NEW _IOW(FT_REF, 0x00, int)
#define FUSION_REF_UP _IOW(FT_REF, 0x01, int)
#define FUSION_REF_UP_GLOBAL _IOW(FT_REF, 0x02, int)
#define FUSION_REF_DOWN _IOW(FT_REF, 0x03, int)
#define FUSION_REF_DOWN_GLOBAL _IOW(FT_REF, 0x04, int)
#define FUSION_REF_ZERO_LOCK _IOW(FT_REF, 0x05, int)
#define FUSION_REF_ZERO_TRYLOCK _IOW(FT_REF, 0x06, int)
#define FUSION_REF_UNLOCK _IOW(FT_REF, 0x07, int)
#define FUSION_REF_STAT _IOW(FT_REF, 0x08, int)
#define FUSION_REF_WATCH _IOW(FT_REF, 0x09, FusionRefWatch)
#define FUSION_REF_INHERIT _IOW(FT_REF, 0x0A, FusionRefInherit)
#define FUSION_REF_DESTROY _IOW(FT_REF, 0x0B, int)
#define FUSION_SKIRMISH_NEW _IOW(FT_SKIRMISH, 0x00, int)
#define FUSION_SKIRMISH_PREVAIL _IOW(FT_SKIRMISH, 0x01, int)
#define FUSION_SKIRMISH_SWOOP _IOW(FT_SKIRMISH, 0x02, int)
#define FUSION_SKIRMISH_DISMISS _IOW(FT_SKIRMISH, 0x03, int)
#define FUSION_SKIRMISH_DESTROY _IOW(FT_SKIRMISH, 0x04, int)
#define FUSION_SKIRMISH_LOCK_COUNT _IOW(FT_SKIRMISH, 0x05, int)
#define FUSION_PROPERTY_NEW _IOW(FT_PROPERTY, 0x00, int)
#define FUSION_PROPERTY_LEASE _IOW(FT_PROPERTY, 0x01, int)
#define FUSION_PROPERTY_PURCHASE _IOW(FT_PROPERTY, 0x02, int)
#define FUSION_PROPERTY_CEDE _IOW(FT_PROPERTY, 0x03, int)
#define FUSION_PROPERTY_HOLDUP _IOW(FT_PROPERTY, 0x04, int)
#define FUSION_PROPERTY_DESTROY _IOW(FT_PROPERTY, 0x05, int)
#define FUSION_REACTOR_NEW _IOW(FT_REACTOR, 0x00, int)
#define FUSION_REACTOR_ATTACH _IOW(FT_REACTOR, 0x01, int)
#define FUSION_REACTOR_DETACH _IOW(FT_REACTOR, 0x02, int)
#define FUSION_REACTOR_DISPATCH _IOW(FT_REACTOR, 0x03, FusionReactorDispatch)
#define FUSION_REACTOR_DESTROY _IOW(FT_REACTOR, 0x04, int)
#define FUSION_SHMPOOL_NEW _IOW(FT_SHMPOOL, 0x00, FusionSHMPoolNew)
#define FUSION_SHMPOOL_ATTACH _IOW(FT_SHMPOOL, 0x01, FusionSHMPoolAttach)
#define FUSION_SHMPOOL_DETACH _IOW(FT_SHMPOOL, 0x02, int)
#define FUSION_SHMPOOL_DISPATCH _IOW(FT_SHMPOOL, 0x03, FusionSHMPoolDispatch)
#define FUSION_SHMPOOL_DESTROY _IOW(FT_SHMPOOL, 0x04, int)
#endif