URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/tags/gnu-src/gdb-7.2/gdb-7.2-or32-1.0rc3/gdb/osf-share
- from Rev 330 to Rev 513
- ↔ Reverse comparison
Rev 330 → Rev 513
/cma_tcb_defs.h
0,0 → 1,269
/* |
* (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC. |
* (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY |
* (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION |
* (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems |
* To anyone who acknowledges that this file is provided "AS IS" without |
* any express or implied warranty: permission to use, copy, modify, and |
* distribute this file for any purpose is hereby granted without fee, |
* provided that the above copyright notices and this notice appears in |
* all source code copies, and that none of the names listed above be used |
* in advertising or publicity pertaining to distribution of the software |
* without specific, written prior permission. None of these organizations |
* makes any representations about the suitability of this software for |
* any purpose. |
*/ |
/* |
* TCB-related type definitions. |
*/ |
|
#ifndef CMA_TCB_DEFS |
#define CMA_TCB_DEFS |
|
/* |
* INCLUDE FILES |
*/ |
# if !_CMA_THREAD_SYNC_IO_ |
# include <cma_thread_io.h> |
# endif |
#include <cma.h> |
#include <cma_debug_client.h> |
#include <cma_attr.h> |
#include <cma_defs.h> |
#include <cma_handle.h> |
#include <cma_queue.h> |
#if _CMA_OS_ == _CMA__UNIX |
# if defined(SNI_DCOSX) |
# include <sys/ucontext.h> |
# endif |
# include <signal.h> |
#endif |
#include <cma_sched.h> |
|
/* |
* CONSTANTS AND MACROS |
*/ |
|
#if _CMA_PLATFORM_ == _CMA__IBMR2_UNIX |
# define cma__c_ibmr2_ctx_stack_size 2048 |
# define cma__c_ibmr2_ctx_stack_top (cma__c_ibmr2_ctx_stack_size - 1) |
#endif |
|
/* |
* TYPEDEFS |
*/ |
|
#ifndef __STDC__ |
# if _CMA_HARDWARE_ != _CMA__HPPA |
struct CMA__T_SEMAPHORE; |
# endif |
struct CMA__T_INT_CV; |
struct CMA__T_INT_MUTEX; |
struct CMA__T_INT_TCB; |
#endif |
|
typedef cma_t_address *cma__t_context_list; |
|
typedef struct CMA__T_TCB_PAD { |
/* |
* Adjust to align the tcb prolog at byte 32. |
* 12 bytes are required as object header is currently |
* 20 bytes long. |
*/ |
cma_t_integer pad1; /* pad bytes */ |
cma_t_integer pad2; /* pad bytes */ |
cma_t_integer pad3; /* pad bytes */ |
} cma__t_tcb_pad; |
|
#if (_CMA_OS_ == _CMA__UNIX) && !_CMA_THREAD_SYNC_IO_ |
typedef struct CMA__T_TCB_SELECT { |
cma__t_queue queue; |
#if (_CMA_UNIX_TYPE != _CMA__SVR4) |
cma__t_file_mask *rfds; |
cma__t_file_mask *wfds; |
cma__t_file_mask *efds; |
#else |
cma__t_poll_info poll_info; |
#endif /* (_CMA_UNIX_TYPE != _CMA__SVR4) */ |
cma_t_integer nfound; |
} cma__t_tcb_select; |
#endif |
|
typedef struct CMA__T_TCB_TIME { |
cma__t_queue queue; /* must be first entry! */ |
cma_t_integer mode; |
struct CMA__T_SEMAPHORE *semaphore; /* used for timed semaphores */ |
cma_t_date_time wakeup_time; |
cma_t_integer quanta_remaining; |
} cma__t_tcb_time; |
|
typedef enum CMA__T_DEBEVT { |
cma__c_debevt_activating = 1, /* First transition to running */ |
cma__c_debevt_running = 2, /* Any transition to running */ |
cma__c_debevt_preempting = 3, /* Preemted (replaced) another thread */ |
cma__c_debevt_blocking = 4, /* Any transition to blocked */ |
cma__c_debevt_terminating = 5, /* Final state transition */ |
cma__c_debevt_term_alert = 6, /* Terminated due to alert/cancel */ |
cma__c_debevt_term_exc = 7, /* Terminated due to exception */ |
cma__c_debevt_exc_handled = 8 /* Exception is being handled */ |
} cma__t_debevt; |
|
#define cma__c_debevt__first ((cma_t_integer)cma__c_debevt_activating) |
#define cma__c_debevt__last ((cma_t_integer)cma__c_debevt_exc_handled) |
#define cma__c_debevt__dim (cma__c_debevt__last + 1) |
|
/* |
* Type defining thread substate, which is used by the debugger. |
* If the state is blocked, substate indicates WHY the thread is blocked. |
*/ |
typedef enum CMA__T_SUBSTATE { |
cma__c_substa_normal = 0, |
cma__c_substa_mutex = 1, |
cma__c_substa_cv = 2, |
cma__c_substa_timed_cv = 3, |
cma__c_substa_term_alt = 4, |
cma__c_substa_term_exc = 5, |
cma__c_substa_delay =6, |
cma__c_substa_not_yet_run = 7 |
} cma__t_substate; |
#define cma__c_substa__first ((cma_t_integer)cma__c_substa_normal) |
#define cma__c_substa__last ((cma_t_integer)cma__c_substa_not_yet_run) |
#define cma__c_substa__dim (cma__c_substa__last + 1) |
|
|
/* |
* Per-thread state for the debugger |
*/ |
typedef struct CMA__T_TCB_DEBUG { |
cma_t_boolean on_hold; /* Thread was put on hold by debugger */ |
cma_t_boolean activated; /* Activation event was reported */ |
cma_t_boolean did_preempt; /* Thread preempted prior one */ |
cma_t_address start_pc; /* Start routine address */ |
cma_t_address object_addr; /* Addr of thread object */ |
cma__t_substate substate; /* Reason blocked, terminated, etc.*/ |
cma_t_boolean notify_debugger;/* Notify debugger thread is running */ |
cma_t_address SPARE2; /* SPARE */ |
cma_t_address SPARE3; /* SPARE */ |
struct CMA__T_INT_TCB |
*preempted_tcb; /* TCB of thread that got preempted */ |
cma_t_boolean flags[cma__c_debevt__dim]; |
/* Events enabled for this thread */ |
} cma__t_tcb_debug; |
|
typedef struct CMA__T_TCB_SCHED { |
cma_t_integer adj_time; /* Abs. time in ticks of last prio adj */ |
cma_t_integer tot_time; /* Weighted ave in ticks (scaled) */ |
cma_t_integer time_stamp; /* Abs. time in ticks of last update */ |
cma_t_integer cpu_time; /* Weighted average in ticks */ |
cma_t_integer cpu_ticks; /* # of ticks while comp. (scaled) */ |
cma_t_integer q_num; /* Number of last ready queue on */ |
cma_t_priority priority; /* Thread priority */ |
cma_t_sched_policy policy; /* Scheduling policy of thread */ |
cma_t_boolean rtb; /* "Run 'Till Block" scheduling */ |
cma_t_boolean spp; /* "Strict Priority Preemption" sched */ |
cma_t_boolean fixed_prio; /* Fixed priority */ |
cma__t_sched_class class; /* Scheduling class */ |
struct CMA__T_VP *processor; /* Current processor (if running) */ |
} cma__t_tcb_sched; |
|
typedef struct CMA__T_INT_ALERT { |
cma_t_boolean pending : 1; /* alert_pending bit */ |
cma_t_boolean g_enable : 1; /* general delivery state */ |
cma_t_boolean a_enable : 1; /* asynchronous delivery state */ |
cma_t_integer spare : 29; /* Pad to longword */ |
cma_t_natural count; /* Alert scope nesting count */ |
} cma__t_int_alert; |
|
typedef enum CMA__T_STATE { |
cma__c_state_running = 0, /* For consistency with initial TCB */ |
cma__c_state_ready = 1, |
cma__c_state_blocked = 2, |
cma__c_state_terminated = 3 |
} cma__t_state; |
#define cma__c_state__first ((cma_t_integer)cma__c_state_running) |
#define cma__c_state__last ((cma_t_integer)cma__c_state_terminated) |
#define cma__c_state__dim (cma__c_state__last + 1) |
|
typedef enum CMA__T_THKIND { |
cma__c_thkind_initial = 0, /* Initial thread */ |
cma__c_thkind_normal = 1, /* Normal thread */ |
cma__c_thkind_null = 2 /* A null thread */ |
} cma__t_thkind; |
#define cma__c_thkind__first ((cma_t_integer)cma__c_thkind_initial) |
#define cma__c_thkind__last ((cma_t_integer)cma__c_thkind_null) |
#define cma__c_thkind__dim (cma__c_thkind__last + 1) |
|
typedef enum CMA__T_SYSCALL_STATE { |
cma__c_syscall_ok = 1, /* syscall was not interrupted */ |
cma__c_syscall_intintrpt = 1, /* syscall was interrupted by VTALRM */ |
cma__c_syscall_extintrpt = 2 /* syscall was interrupted by external signal */ |
} cma__t_syscall_state; |
|
|
typedef struct CMA__T_INT_TCB { |
/* |
* Fixed part of TCB. |
* Modifications to the following three fields must be coordinated. |
* The object header must always be first, and the prolog must always |
* remain at the same offset (32) for all time. Thus the object header |
* must never grow beyond a maximum of 32 bytes. |
*/ |
cma__t_object header; /* Common object header */ |
cma__t_tcb_pad pad1; /* Pad required to align prolog */ |
cma_t_tcb_prolog prolog; /* Standard prolog for tasks, threads */ |
|
/* |
* Floating part of TCB (fields here on are free to be moved and resized). |
*/ |
cma__t_queue threads; /* List of all known threads */ |
cma__t_int_attr *attributes; /* Backpointer to attr obj */ |
cma__t_state state; /* Current state of thread */ |
cma__t_thkind kind; /* Which kind of thread */ |
struct CMA__T_INT_MUTEX |
*mutex; /* Mutex to control TCB access */ |
struct CMA__T_INT_CV |
*term_cv; /* CV for join */ |
struct CMA__T_INT_MUTEX |
*tswait_mutex; /* Mutex for thread-synchronous waits */ |
struct CMA__T_INT_CV |
*tswait_cv; /* CV for thread-synchronous waits */ |
cma_t_start_routine start_code; /* Address of start routine */ |
cma_t_address start_arg; /* Argument to pass to start_code */ |
cma__t_queue stack; /* Queue header for stack descr. */ |
cma_t_natural context_count; /* Size of context array */ |
cma__t_context_list contexts; /* Context value array pointer */ |
cma_t_exit_status exit_status; /* Exit status of thread */ |
cma_t_address return_value; /* Thread's return value */ |
cma__t_async_ctx async_ctx; /* Asynchronous context switch info */ |
cma__t_static_ctx static_ctx; /* Static context switch information */ |
cma_t_integer event_status; /* Status of semaphore operation */ |
cma__t_tcb_time timer; /* Time info for dispatcher */ |
cma__t_tcb_sched sched; /* Scheduler info */ |
cma__t_tcb_debug debug; /* Debugger info */ |
#if _CMA_OS_ == _CMA__UNIX |
# if !_CMA_THREAD_SYNC_IO_ |
cma__t_tcb_select select; /* Select info for timed selects */ |
# endif |
struct sigaction sigaction_data[NSIG]; |
#endif |
cma_t_natural syscall_state; /* set if one of the cma wrapped syscalls was interrupted. */ |
cma_t_boolean detached; /* Set if already detached */ |
cma_t_boolean terminated; /* Set if terminated */ |
cma_t_integer joiners; /* Count of joiners, for zombie frees */ |
cma__t_int_alert alert; /* Current alert state info */ |
struct CMA__T_INT_CV |
*wait_cv; /* CV thread is currently waiting on */ |
struct CMA__T_INT_MUTEX |
*wait_mutex; /* Mutex thread is waiting on */ |
struct EXC_CONTEXT_T |
*exc_stack; /* Top of exception stack */ |
#if _CMA_PLATFORM_ == _CMA__IBMR2_UNIX |
char ctx_stack[cma__c_ibmr2_ctx_stack_size]; |
#endif |
cma_t_integer thd_errno; /* Per-thread errno value */ |
#if _CMA_OS_ == _CMA__VMS |
cma_t_integer thd_vmserrno; /* Per-thread VMS errno value */ |
#endif |
} cma__t_int_tcb; |
|
#endif |
cma_tcb_defs.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_attr.h
===================================================================
--- cma_attr.h (nonexistent)
+++ cma_attr.h (revision 513)
@@ -0,0 +1,341 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for attributes object
+ */
+
+#ifndef CMA_ATTR
+#define CMA_ATTR
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#ifdef __hpux
+# include
+#endif
+#if _CMA_UNIX_TYPE == _CMA__SVR4
+#include
+#endif
+/*
+ * CONSTANTS AND MACROS
+ */
+
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_get_priority - Performs the work of cma_attr_get_priority
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attribute object to get from
+ * cma_t_priority *_setting_ - Current setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * priority
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_attr_get_priority(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ (_int_att_) = cma__validate_default_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ (*(_setting_)) = (_int_att_)->priority; \
+ cma__int_unlock ((_int_att_)->mutex); \
+ }
+
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_get_sched - Performs work of cma_attr_get_sched
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ _ Attributes object used
+ * cma_t_sched_policy *_setting_ - Current setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * scheduling policy
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_attr_get_sched(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ (_int_att_) = cma__validate_default_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ (*(_setting_)) = (_int_att_)->policy; \
+ cma__int_unlock ((_int_att_)->mutex); \
+ }
+
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_get_inherit_sched - Performs work of
+ * cma_attr_get_inherit_sched
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attributes object to use
+ * cma_t_sched_inherit *_setting_ - Current setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * Inheritable scheduling policy
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_attr_get_inherit_sched(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ (_int_att_) = cma__validate_default_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ (*(_setting_)) \
+ = ((_int_att_)->inherit_sched ? cma_c_sched_inherit : cma_c_sched_use_default); \
+ cma__int_unlock ((_int_att_)->mutex); \
+ }
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_set_stacksize - Performs work for cma_attr_set_stacksize
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attributes object to use
+ * cma_t_natural _setting_ - Setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * none
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * Change attribute objects stack size setting
+ */
+#define cma__int_attr_set_stacksize(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ if ((_setting_) <= 0) \
+ cma__error (cma_s_badparam); \
+ _int_att_ = cma__validate_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ _int_att_->stack_size = cma__roundup_chunksize(_setting_); \
+ cma__free_cache (_int_att_, cma__c_obj_tcb); \
+ _int_att_->cache[cma__c_obj_tcb].revision++; \
+ _int_att_->cache[cma__c_obj_stack].revision++; \
+ cma__int_unlock (_int_att_->mutex); \
+ }
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_get_stacksize - Performs work of cma_attr_get_stacksize
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attributes object to use
+ * cma_t_natural *_setting_ - Current setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * Attribute objects stack size setting
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_attr_get_stacksize(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ (_int_att_) = cma__validate_default_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ (*(_setting_)) = (_int_att_)->stack_size; \
+ cma__int_unlock ((_int_att_)->mutex); \
+ }
+
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_set_guardsize - Performs work for cma_attr_set_guardsize
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attributes object to use
+ * cma_t_natural _setting_ - Setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * none
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * Change attribute objects guard size setting
+ */
+#define cma__int_attr_set_guardsize(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ _int_att_ = cma__validate_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ _int_att_->guard_size = cma__roundup_chunksize(_setting_); \
+ cma__free_cache (_int_att_, cma__c_obj_tcb); \
+ _int_att_->cache[cma__c_obj_tcb].revision++; \
+ _int_att_->cache[cma__c_obj_stack].revision++; \
+ cma__int_unlock (_int_att_->mutex); \
+ }
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_attr_get_guardsize - Performs work of cma_attr_get_guardsize
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma_t_attr *_att_ - Attributes object to use
+ * cma_t_natural *_setting_ - Current setting
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * Attribute objects guard size setting
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_attr_get_guardsize(_att_,_setting_) { \
+ cma__t_int_attr *_int_att_; \
+ (_int_att_) = cma__validate_default_attr (_att_); \
+ cma__int_lock ((_int_att_)->mutex); \
+ (*(_setting_)) = (_int_att_)->guard_size; \
+ cma__int_unlock ((_int_att_)->mutex); \
+ }
+
+/*
+ * TYPEDEFS
+ */
+#ifndef __STDC__
+struct CMA__T_INT_MUTEX; /* Avoid circular dependency */
+#endif
+
+typedef struct CMA__T_CACHE {
+ cma_t_natural revision; /* Revisions */
+ cma_t_natural count;
+ cma__t_queue queue; /* Cache headers */
+ } cma__t_cache;
+
+typedef struct CMA__T_INT_ATTR {
+ cma__t_object header; /* Common header */
+ struct CMA__T_INT_ATTR *attributes; /* Point to controlling attr */
+ struct CMA__T_INT_MUTEX *mutex; /* Serialize access to object */
+ cma_t_priority priority; /* Priority of new thread */
+ cma_t_sched_policy policy; /* Sched policy of thread */
+ cma_t_boolean inherit_sched; /* Is scheduling inherited? */
+ cma_t_natural stack_size; /* Size of stack (bytes) */
+ cma_t_natural guard_size; /* Size of guard (bytes) */
+ cma_t_mutex_kind mutex_kind; /* Mutex kind */
+ cma__t_cache cache[cma__c_obj_num]; /* Cache information */
+ cma_t_boolean delete_pending; /* attr. obj. is deleted */
+ cma_t_natural refcnt; /* Number of objects using attr. obj */
+ } cma__t_int_attr;
+
+/*
+ * GLOBAL DATA
+ */
+
+extern cma__t_int_attr cma__g_def_attr;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void cma__destroy_attributes (cma__t_int_attr *);
+
+extern void cma__free_attributes (cma__t_int_attr *);
+
+extern void cma__free_cache (cma__t_int_attr *,cma_t_natural );
+
+extern cma__t_int_attr *cma__get_attributes (cma__t_int_attr *);
+
+extern void cma__init_attr (void);
+
+extern void cma__reinit_attr (cma_t_integer);
+
+#endif
cma_attr.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_list.h
===================================================================
--- cma_list.h (nonexistent)
+++ cma_list.h (revision 513)
@@ -0,0 +1,84 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for generic list functions operating on singly linked
+ * null-terminated lists. Items may not be REMOVED from the list! The
+ * intent is that the list can be traversed (for read-only operations)
+ * without locking, since insertion is "safe" (though not truely
+ * atomic). THIS ASSUMES THAT THE HARDWARE MAKES WRITES VISIBLE TO READS
+ * IN THE ORDER IN WHICH THEY OCCURRED! WITHOUT SUCH READ/WRITE
+ * ORDERING, IT MAY BE NECESSARY TO INSERT "BARRIERS" TO PRODUCE THE
+ * REQUIRED VISIBILITY!
+ */
+
+#ifndef CMA_LIST
+#define CMA_LIST
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma__c_null_list ((cma__t_list *)cma_c_null_ptr)
+
+/*
+ * Test whether a list is empty. Return cma_c_true if so, else
+ * cma_c_false.
+ */
+#define cma__list_empty(head) ((head)->link == cma__c_null_list)
+
+/*
+ * Initialize a queue header to empty.
+ */
+#define cma__list_init(head) (void)((head)->link = cma__c_null_list)
+
+/*
+ * Insert an element in a list following the specified item (or at the
+ * beginning of the list if "list" is the list head). NOTE: insertion
+ * operations should be interlocked by the caller!
+ */
+#define cma__list_insert(element,list) (void)( \
+ (element)->link = (list)->link, \
+ (list)->link = (element))
+
+/*
+ * Return the next item in a list (or the first, if the address is of the
+ * list header)
+ */
+#define cma__list_next(element) ((element)->link)
+
+/*
+ * TYPEDEFS
+ */
+
+typedef struct CMA__T_LIST {
+ struct CMA__T_LIST *link; /* Forward link */
+ } cma__t_list;
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+#endif
cma_list.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_errors.h
===================================================================
--- cma_errors.h (nonexistent)
+++ cma_errors.h (revision 513)
@@ -0,0 +1,55 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * This module is the interface between CMA services and
+ * the platform-specific error reporting mechanism.
+ */
+
+#ifndef CMA_ERRORS
+#define CMA_ERRORS
+
+/*
+ * INCLUDE FILES
+ */
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+/*
+ * The cma__bugcheck function will print information to stderr (or sys$error
+ * on VMS), and more extensive information to the file cma_dump.log in the
+ * current working directory.
+ */
+extern void cma__bugcheck (char *,...);
+
+extern void cma__error (int);
+
+extern void cma__unimplemented (void);
+
+#endif
cma_errors.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_util.h
===================================================================
--- cma_util.h (nonexistent)
+++ cma_util.h (revision 513)
@@ -0,0 +1,125 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for CMA internal UTIL operations
+ */
+
+#ifndef CMA_UTIL
+#define CMA_UTIL
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+
+#if _CMA_OS_ == _CMA__VMS
+# include
+#endif
+
+#if _CMA_VENDOR_ == _CMA__SUN
+# include
+#else
+# include
+#endif
+
+#if _CMA_OS_ == _CMA__UNIX
+# include
+#endif
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma__c_buffer_size 256 /* Size of output buffer */
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * Alternate eol routine
+ */
+typedef void (*cma__t_eol_routine) (char *);
+
+#if _CMA_OS_ == _CMA__VMS
+ typedef struct CMA__T_VMSFILE {
+ struct RAB rab;
+ struct FAB fab;
+ } cma__t_vmsfile, *cma__t_file;
+#elif ( _CMA_UNIX_TYPE == _CMA__SVR4 )
+ typedef int cma__t_file;
+#else
+ typedef FILE *cma__t_file;
+#endif
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void cma__abort (void);
+
+extern cma_t_integer cma__atol (char *);
+
+extern cma_t_integer cma__atoi (char *);
+
+extern char * cma__getenv (char *,char *,int);
+
+extern int cma__gettimespec (struct timespec *);
+
+extern cma__t_file cma__int_fopen (char *,char *);
+
+#ifndef NDEBUG
+extern void cma__init_trace (char *_env);
+#endif
+
+extern char * cma__memcpy (char *,char *,cma_t_integer);
+
+#ifndef cma__memset
+extern char * cma__memset (char *,cma_t_integer,cma_t_integer);
+#endif
+
+extern void cma__putformat (char *,char *,...);
+
+extern void cma__putstring (char *,char *);
+
+extern void cma__putint (char *,cma_t_integer);
+
+extern void cma__putint_5 (char *,cma_t_integer);
+
+extern void cma__putint_10 (char *,cma_t_integer);
+
+extern void cma__puthex (char *,cma_t_integer);
+
+extern void cma__puthex_8 (char *,cma_t_integer);
+
+extern void cma__puteol (char *);
+
+extern void cma__set_eol_routine (cma__t_eol_routine,cma__t_eol_routine *);
+
+extern cma_t_integer cma__strlen (char *);
+
+extern int cma__strncmp (char *,char *,cma_t_integer);
+
+extern char *cma__gets (char *,char *);
+
+#endif
cma_util.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_stack_int.h
===================================================================
--- cma_stack_int.h (nonexistent)
+++ cma_stack_int.h (revision 513)
@@ -0,0 +1,136 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for stack management (internal to cma_stack.c, but
+ * separate for convenience, and unit testing).
+ */
+
+#ifndef CMA_STACK_INT
+#define CMA_STACK_INT
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma___c_first_free_chunk 0
+#define cma___c_min_count 2 /* Smallest number of chunks to leave */
+#define cma___c_end (-1) /* End of free list (flag) */
+#define cma__c_yellow_size 0
+
+/*
+ * Cluster types
+ */
+#define cma___c_cluster 0 /* Default cluster */
+#define cma___c_bigstack 1 /* Looks like a cluster, but it's a stack */
+
+
+#define cma___c_null_cluster (cma___t_cluster *)cma_c_null_ptr
+
+
+/*
+ * TYPEDEFS
+ */
+
+#ifndef __STDC__
+struct CMA__T_INT_STACK;
+#endif
+
+typedef cma_t_natural cma___t_index; /* Type for chunk index */
+
+typedef struct CMA___T_CLU_DESC {
+ cma__t_list list; /* Queue element for cluster list */
+ cma_t_integer type; /* Type of cluster */
+ cma_t_address stacks;
+ cma_t_address limit;
+ } cma___t_clu_desc;
+
+typedef union CMA___T_MAP_ENTRY {
+ struct {
+ cma__t_int_tcb *tcb; /* TCB associated with stack chunk */
+ struct CMA__T_INT_STACK *stack; /* Stack desc. ass. with stack chunk */
+ } mapped;
+ struct {
+ cma___t_index size; /* Number of chunks in block */
+ cma___t_index next; /* Next free block */
+ } free;
+ } cma___t_map_entry;
+
+/*
+ * NOTE: It is VERY IMPORTANT that both cma___t_cluster and cma___t_bigstack
+ * begin with the cma___t_clu_desc structure, as there is some code in the
+ * stack manager that relies on being able to treat both as equivalent!
+ */
+typedef struct CMA___T_CLUSTER {
+ cma___t_clu_desc desc; /* Describe this cluster */
+ cma___t_map_entry map[cma__c_chunk_count]; /* thread map */
+ cma___t_index free; /* First free chunk index */
+ } cma___t_cluster;
+
+/*
+ * NOTE: It is VERY IMPORTANT that both cma___t_cluster and cma___t_bigstack
+ * begin with the cma___t_clu_desc structure, as there is some code in the
+ * stack manager that relies on being able to treat both as equivalent!
+ */
+typedef struct CMA___T_BIGSTACK {
+ cma___t_clu_desc desc; /* Describe this cluster */
+ cma__t_int_tcb *tcb; /* TCB associated with stack */
+ struct CMA__T_INT_STACK *stack; /* Stack desc. ass. with stack */
+ cma_t_natural size; /* Size of big stack */
+ cma_t_boolean in_use; /* Set if allocated */
+ } cma___t_bigstack;
+
+#if _CMA_PROTECT_MEMORY_
+typedef struct CMA___T_INT_HOLE {
+ cma__t_queue link; /* Link holes together */
+ cma_t_boolean protected; /* Set when pages are protected */
+ cma_t_address first; /* First protected byte */
+ cma_t_address last; /* Last protected byte */
+ } cma___t_int_hole;
+#endif
+
+typedef struct CMA__T_INT_STACK {
+ cma__t_object header; /* Common header (sequence, type info */
+ cma__t_int_attr *attributes; /* Backpointer to attr obj */
+ cma___t_cluster *cluster; /* Stack's cluster */
+ cma_t_address stack_base; /* base address of stack */
+ cma_t_address yellow_zone; /* first address of yellow zone */
+ cma_t_address last_guard; /* last address of guard pages */
+ cma_t_natural first_chunk; /* First chunk allocated */
+ cma_t_natural chunk_count; /* Count of chunks allocated */
+ cma__t_int_tcb *tcb; /* TCB backpointer */
+#if _CMA_PROTECT_MEMORY_
+ cma___t_int_hole hole; /* Description of hole */
+#endif
+ } cma__t_int_stack;
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+#endif
cma_stack_int.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_debug_client.h
===================================================================
--- cma_debug_client.h (nonexistent)
+++ cma_debug_client.h (revision 513)
@@ -0,0 +1,195 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file providing access to CMA clients that implement
+ * language run-times to the CMA debugger capabilities.
+ *
+ * NOTE: the clients that are able to use this interface is
+ * very limited because clients needing task debugging must have
+ * support in the system debugger as well as here (at present).
+ * The following are the only legitimate clients of this interface:
+ * ADA runtime, C++ tasking library, and CMA.
+ *
+ *FIX-ME* We shall endeavor to extend these capabilities so that the
+ * all-platform CMA debugger CMA_DEBUG and any client can layer
+ * on thread debugging. But that is still an open design problem.
+ * The design here does not preclude that extension (for example,
+ * the identity of the debug-client is indicated in an "open"
+ * manner by using the CMA context key as the identifier.
+ */
+
+#ifndef CMA_DEBUG_CLIENT
+#define CMA_DEBUG_CLIENT
+
+/*
+ * INCLUDE FILES
+ */
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * Type describing constants for a valid TCB sentinel.
+ * Exactly one value is valid, but we provide a symbolic name for
+ * at least one invalid sentinel as a convenience.
+ */
+typedef enum CMA_T_TCB_SENTINEL {
+ cma_c_tcb_sentinel_nogood = 0, /* Invalid sentinel constant */
+ cma_c_tcb_sentinel = 0x0ACEFACE /* Valid TCB sentinel */
+ } cma_t_tcb_sentinel;
+
+/*
+ * Type describing pad fields needed to align the "standard prolog"
+ * to the right byte at the front of each TCB. These fields are
+ * free to be put to any use by the client.
+ *
+ * This is 32 bytes long and is fixed at this size for all clients
+ * and CMA, for all time.
+ */
+typedef struct CMA_T_TCB_PRIVATE {
+ cma_t_integer pad1;
+ cma_t_integer pad2;
+ cma_t_integer pad3;
+ cma_t_integer pad4;
+ cma_t_integer pad5;
+ cma_t_integer pad6;
+ cma_t_integer pad7;
+ cma_t_integer pad8;
+ } cma_t_tcb_private;
+
+/*
+ * Type describing the "standard prolog" that clients should use
+ * within their task control blocks. We assume that the client will
+ * store their "task control block" as a per-thread context under
+ * the context key specified here.
+ */
+typedef struct CMA_T_TCB_PROLOG {
+ cma_t_tcb_sentinel sentinel; /* Validity sentinel */
+ cma_t_thread client_thread; /* Thread corresonding to task */
+ cma_t_key client_key; /* Context key this is stored under */
+ cma_t_address reserved1; /* Must be zero, reserved to CMA */
+ } cma_t_tcb_prolog;
+
+/*
+ * Type defining the layout of all TCBs and TASKS. This format
+ * ensures that tasks will be self-identifying to the debugger.
+ * this layout must never change as the CMA DEBUG Clients cannot
+ * be changed after CMA ships.
+ */
+typedef struct CMA_T_TCB_HEADER {
+ cma_t_tcb_private IGNORED; /* TCB fields private to the client */
+ cma_t_tcb_prolog prolog; /* The standard prolog goes here */
+ } cma_t_tcb_header;
+
+
+/*
+ * Type describing the kinds of information that a CMA debug
+ * client can GET about a thread.
+ */
+typedef enum CMA_T_DEBUG_GET {
+ /*
+ * All of the following items use a buffer whose size is
+ * four bytes. (That is four must be passed as the buffer_size
+ * parameter to cma_debug_get.)
+ */
+ cma_c_debget_guardsize = 1, /* Current guard size (bytes) */
+ cma_c_debget_is_held = 2, /* Is it on hold? */
+ cma_c_debget_is_initial = 3, /* Is it the initial thread? */
+ cma_c_debget_number = 4, /* Thread's number */
+ cma_c_debget_stack_ptr = 5, /* Current stack pointer */
+ cma_c_debget_stack_base = 6, /* Stack base address */
+ cma_c_debget_stack_top = 7, /* Stack top address */
+ cma_c_debget_sched_state = 8, /* Scheduler state
+ * 0 - run
+ * 1 - ready
+ * 2 - blocked
+ * 3 - terminated
+ */
+ cma_c_debget_reserve_size = 9, /* Size of stack reserve (bytes) */
+ cma_c_debget_base_prio = 10, /* Base priority */
+ cma_c_debget_priority = 11, /* Current priority */
+ cma_c_debget_regs = 12, /* Register set (and proc. state) */
+ cma_c_debget_alt_pending = 13, /* Alert is pending */
+ cma_c_debget_alt_a_enable = 14, /* Asynch alert delivery enabled */
+ cma_c_debget_alt_g_enable = 15, /* General alert delivery enabled */
+ cma_c_debget_substate = 16, /* Substate (or wait state) */
+ cma_c_debget_object_addr = 17, /* Address of thread object */
+ cma_c_debget_thkind = 18, /* Kind of thread */
+ cma_c_debget_detached = 19, /* Thread is detached */
+ cma_c_debget_tcb_size = 20, /* TCB size */
+ cma_c_debget_start_pc = 21, /* Start address */
+ cma_c_debget_next_pc = 22, /* Next instruction */
+ cma_c_debget_policy = 23, /* Sched policy */
+ cma_c_debget_stack_yellow = 24, /* Addr of start of guard area */
+ cma_c_debget_stack_default = 25 /* True if on default stack */
+
+ } cma_t_debug_get;
+
+/*
+ * Type describing the kinds of information that a CMA debug
+ * client can SET (or change) about a thread using cma_debug_set.
+ */
+typedef enum CMA_T_DEBUG_SET {
+ /*
+ * All of the following items use a buffer whose size is
+ * four bytes. (That is four must be passed as the buffer_size
+ * parameter to cma_debug_set.)
+ */
+ cma_c_debset_priority = 1, /* Set the priority */
+ cma_c_debset_policy = 2, /* Set the sched policy */
+ cma_c_debset_hold = 3, /* Put thread on hold */
+ cma_c_debset_regs = 4 /* Set the regs and proc. state */
+
+ } cma_t_debug_set;
+
+
+/*
+ * GLOBAL DATA
+ *
+ * none
+ */
+
+/*
+ * EXTERNAL INTERFACES
+ */
+
+/*
+ * Routine to register with the CMA debug dispatcher.
+ */
+extern void cma_debug_register (cma_t_address,cma_t_key,cma_t_integer,cma_t_boolean);
+
+/*
+ * Routine to get get thread state needed by the CMA debug client.
+ */
+extern void cma_debug_get (cma_t_thread *,cma_t_debug_get,cma_t_address,cma_t_integer);
+
+/*
+ * Get thread context given an sp and a key
+ */
+extern void cma_debug_get_sp_context (cma_t_address,cma_t_key,cma_t_address *);
+
+/*
+ * Routine to set thread state as needed by the CMA debug client.
+ */
+extern void cma_debug_set (cma_t_thread *,cma_t_debug_set,cma_t_address,cma_t_integer);
+
+#endif
cma_debug_client.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_semaphore_defs.h
===================================================================
--- cma_semaphore_defs.h (nonexistent)
+++ cma_semaphore_defs.h (revision 513)
@@ -0,0 +1,46 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for semaphore structure definition.
+ */
+#ifndef CMA_SEMAPHORE_DEFS
+#define CMA_SEMAPHORE_DEFS
+
+/*
+ * INCLUDE FILES
+ */
+#include
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma__c_semaphore_timeout 1
+#define cma__c_semaphore_event 0
+#define cma__c_select_timeout 2
+
+/*
+ * TYPEDEFS
+ */
+
+typedef struct CMA__T_SEMAPHORE {
+ cma__t_queue queue;
+ cma__t_atomic_bit nopending;
+ } cma__t_semaphore;
+
+#endif
cma_semaphore_defs.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_sched.h
===================================================================
--- cma_sched.h (nonexistent)
+++ cma_sched.h (revision 513)
@@ -0,0 +1,279 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for priority scheduling
+ */
+
+
+#ifndef CMA_SCHED
+#define CMA_SCHED
+
+/*
+ * INCLUDE FILES
+ */
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+/*
+ * Scaling factor for integer priority calculations
+ */
+#define cma__c_prio_scale 8
+
+#if _CMA_VENDOR_ == _CMA__APOLLO
+/*
+ * FIX-ME: Apollo cc 6.8 blows contant folded "<<" and ">>"
+ */
+# define cma__scale_up(exp) ((exp) * 256)
+# define cma__scale_dn(exp) ((exp) / 256)
+#else
+# define cma__scale_up(exp) ((exp) << cma__c_prio_scale)
+# define cma__scale_dn(exp) ((exp) >> cma__c_prio_scale)
+#endif
+
+
+/*
+ * Min. num. of ticks between self-adjustments for priority adjusting policies.
+ */
+#define cma__c_prio_interval 10
+
+
+/*
+ * Number of queues in each class of queues
+ */
+#define cma__c_prio_n_id 1 /* Very-low-priority class threads */
+#define cma__c_prio_n_bg 8 /* Background class threads */
+#define cma__c_prio_n_0 1 /* Very low priority throughput quartile */
+#define cma__c_prio_n_1 2 /* Low priority throughput quartile */
+#define cma__c_prio_n_2 3 /* Medium priority throughput quartile */
+#define cma__c_prio_n_3 4 /* High priority throughput quartile */
+#define cma__c_prio_n_rt 1 /* Real Time priority queues */
+
+/*
+ * Number of queues to skip (offset) to get to the queues in this section of LA
+ */
+#define cma__c_prio_o_id 0
+#define cma__c_prio_o_bg cma__c_prio_o_id + cma__c_prio_n_id
+#define cma__c_prio_o_0 cma__c_prio_o_bg + cma__c_prio_n_bg
+#define cma__c_prio_o_1 cma__c_prio_o_0 + cma__c_prio_n_0
+#define cma__c_prio_o_2 cma__c_prio_o_1 + cma__c_prio_n_1
+#define cma__c_prio_o_3 cma__c_prio_o_2 + cma__c_prio_n_2
+#define cma__c_prio_o_rt cma__c_prio_o_3 + cma__c_prio_n_3
+
+/*
+ * Ada_low: These threads are queued in the background queues, thus there
+ * must be enough queues to allow one queue for each Ada priority below the
+ * Ada default.
+ */
+#define cma__c_prio_o_al cma__c_prio_o_bg
+
+/*
+ * Total number of ready queues, for declaration purposes
+ */
+#define cma__c_prio_n_tot \
+ cma__c_prio_n_id + cma__c_prio_n_bg + cma__c_prio_n_rt \
+ + cma__c_prio_n_0 + cma__c_prio_n_1 + cma__c_prio_n_2 + cma__c_prio_n_3
+
+/*
+ * Formulae for determining a thread's priority. Variable priorities (such
+ * as foreground and background) are scaled values.
+ */
+#define cma__sched_priority(tcb) \
+ ((tcb)->sched.class == cma__c_class_fore ? cma__sched_prio_fore (tcb) \
+ :((tcb)->sched.class == cma__c_class_back ? cma__sched_prio_back (tcb) \
+ :((tcb)->sched.class == cma__c_class_rt ? cma__sched_prio_rt (tcb) \
+ :((tcb)->sched.class == cma__c_class_idle ? cma__sched_prio_idle (tcb) \
+ :(cma__bugcheck ("cma__sched_priority: unrecognized class"), 0) ))))
+
+#define cma__sched_prio_fore(tcb) cma__sched_prio_fore_var (tcb)
+#define cma__sched_prio_back(tcb) ((tcb)->sched.fixed_prio \
+ ? cma__sched_prio_back_fix (tcb) : cma__sched_prio_back_var (tcb) )
+#define cma__sched_prio_rt(tcb) ((tcb)->sched.priority)
+#define cma__sched_prio_idle(tcb) ((tcb)->sched.priority)
+
+#define cma__sched_prio_back_fix(tcb) \
+ (cma__g_prio_bg_min + (cma__g_prio_bg_max - cma__g_prio_bg_min) \
+ * ((tcb)->sched.priority + cma__c_prio_o_al - cma__c_prio_o_bg) \
+ / cma__c_prio_n_bg)
+
+/*
+ * FIX-ME: Enable after modeling (if we like it)
+ */
+#if 1
+# define cma__sched_prio_fore_var(tcb) \
+ ((cma__g_prio_fg_max + cma__g_prio_fg_min)/2)
+# define cma__sched_prio_back_var(tcb) \
+ ((cma__g_prio_bg_max + cma__g_prio_bg_min)/2)
+#else
+# define cma__sched_prio_back_var(tcb) cma__sched_prio_fore_var (tcb)
+
+# if 1
+/*
+ * Re-scale, since the division removes the scale factor.
+ * Scale and multiply before dividing to avoid loss of precision.
+ */
+# define cma__sched_prio_fore_var(tcb) \
+ ((cma__g_vp_count * cma__scale_up((tcb)->sched.tot_time)) \
+ / (tcb)->sched.cpu_time)
+# else
+/*
+ * Re-scale, since the division removes the scale factor.
+ * Scale and multiply before dividing to avoid loss of precision.
+ * Left shift the numerator to multiply by two.
+ */
+# define cma__sched_prio_fore_var(tcb) \
+ (((cma__g_vp_count * cma__scale_up((tcb)->sched.tot_time) \
+ * (tcb)->sched.priority * cma__g_init_frac_sum) << 1) \
+ / ((tcb)->sched.cpu_time * (tcb)->sched.priority * cma__g_init_frac_sum \
+ + (tcb)->sched.tot_time))
+# endif
+#endif
+
+/*
+ * Update weighted-averaged, scaled tick counters
+ */
+#define cma__sched_update_time(ave, new) \
+ (ave) = (ave) - ((cma__scale_dn((ave)) - (new)) << (cma__c_prio_scale - 4))
+
+#define cma__sched_parameterize(tcb, policy) { \
+ switch (policy) { \
+ case cma_c_sched_fifo : { \
+ (tcb)->sched.rtb = cma_c_true; \
+ (tcb)->sched.spp = cma_c_true; \
+ (tcb)->sched.fixed_prio = cma_c_true; \
+ (tcb)->sched.class = cma__c_class_rt; \
+ break; \
+ } \
+ case cma_c_sched_rr : { \
+ (tcb)->sched.rtb = cma_c_false; \
+ (tcb)->sched.spp = cma_c_true; \
+ (tcb)->sched.fixed_prio = cma_c_true; \
+ (tcb)->sched.class = cma__c_class_rt; \
+ break; \
+ } \
+ case cma_c_sched_throughput : { \
+ (tcb)->sched.rtb = cma_c_false; \
+ (tcb)->sched.spp = cma_c_false; \
+ (tcb)->sched.fixed_prio = cma_c_false; \
+ (tcb)->sched.class = cma__c_class_fore; \
+ break; \
+ } \
+ case cma_c_sched_background : { \
+ (tcb)->sched.rtb = cma_c_false; \
+ (tcb)->sched.spp = cma_c_false; \
+ (tcb)->sched.fixed_prio = cma_c_false; \
+ (tcb)->sched.class = cma__c_class_back; \
+ break; \
+ } \
+ case cma_c_sched_ada_low : { \
+ (tcb)->sched.rtb = cma_c_false; \
+ (tcb)->sched.spp = cma_c_true; \
+ (tcb)->sched.fixed_prio = cma_c_true; \
+ (tcb)->sched.class = cma__c_class_back; \
+ break; \
+ } \
+ case cma_c_sched_idle : { \
+ (tcb)->sched.rtb = cma_c_false; \
+ (tcb)->sched.spp = cma_c_false; \
+ (tcb)->sched.fixed_prio = cma_c_false; \
+ (tcb)->sched.class = cma__c_class_idle; \
+ break; \
+ } \
+ default : { \
+ cma__bugcheck ("cma__sched_parameterize: bad scheduling Policy"); \
+ break; \
+ } \
+ } \
+ }
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * Scheduling classes
+ */
+typedef enum CMA__T_SCHED_CLASS {
+ cma__c_class_rt,
+ cma__c_class_fore,
+ cma__c_class_back,
+ cma__c_class_idle
+ } cma__t_sched_class;
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * Minimuma and maximum prioirities, for foreground and background threads,
+ * as of the last time the scheduler ran. (Scaled once.)
+ */
+extern cma_t_integer cma__g_prio_fg_min;
+extern cma_t_integer cma__g_prio_fg_max;
+extern cma_t_integer cma__g_prio_bg_min;
+extern cma_t_integer cma__g_prio_bg_max;
+
+/*
+ * The "m" values are the slopes of the four sections of linear approximation.
+ *
+ * cma__g_prio_m_I = 4*N(I)/cma__g_prio_range (Scaled once.)
+ */
+extern cma_t_integer cma__g_prio_m_0,
+ cma__g_prio_m_1,
+ cma__g_prio_m_2,
+ cma__g_prio_m_3;
+
+/*
+ * The "b" values are the intercepts of the four sections of linear approx.
+ * (Not scaled.)
+ *
+ * cma__g_prio_b_I = -N(I)*(I*prio_max + (4-I)*prio_min)/prio_range + prio_o_I
+ */
+extern cma_t_integer cma__g_prio_b_0,
+ cma__g_prio_b_1,
+ cma__g_prio_b_2,
+ cma__g_prio_b_3;
+
+/*
+ * The "p" values are the end points of the four sections of linear approx.
+ *
+ * cma__g_prio_p_I = cma__g_prio_fg_min + (I/4)*cma__g_prio_range
+ *
+ * [cma__g_prio_p_0 is not defined since it is not used (also, it is the same
+ * as cma__g_prio_fg_min).] (Scaled once.)
+ */
+extern cma_t_integer cma__g_prio_p_1,
+ cma__g_prio_p_2,
+ cma__g_prio_p_3;
+
+/*
+ * Points to the next queue for the dispatcher to check for ready threads.
+ */
+extern cma_t_integer cma__g_next_ready_queue;
+
+/*
+ * Points to the queues of virtual processors (for preempt victim search)
+ */
+extern cma__t_queue cma__g_run_vps;
+extern cma__t_queue cma__g_susp_vps;
+extern cma_t_integer cma__g_vp_count;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+#endif
cma_sched.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: README
===================================================================
--- README (nonexistent)
+++ README (revision 513)
@@ -0,0 +1,8 @@
+This directory contains header files necessary to build a thread-aware GDB on
+systems based on OSF's CMA threads package.
+
+The latest version of these header files are available for free from:
+
+ http://www.osf.org/mall/dce/SW-code
+
+Currently, the only port of GDB which supports CMA threads is HP/UX-10.10.
README
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: HP800/cma_thread_io.h
===================================================================
--- HP800/cma_thread_io.h (nonexistent)
+++ HP800/cma_thread_io.h (revision 513)
@@ -0,0 +1,432 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ *
+ * Header file for thread synchrounous I/O
+ */
+
+#ifndef CMA_THREAD_IO
+#define CMA_THREAD_IO
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS
+ */
+
+
+
+/*
+ * Maximum number of files (ie, max_fd+1)
+ */
+#define cma__c_mx_file FD_SETSIZE
+
+/*
+ * Number of bits per file descriptor bit mask (ie number of bytes * bits/byte)
+ */
+#define cma__c_nbpm NFDBITS
+
+/*
+ * TYPE DEFINITIONS
+ */
+
+typedef enum CMA__T_IO_TYPE {
+ cma__c_io_read = 0,
+ cma__c_io_write = 1,
+ cma__c_io_except = 2
+ } cma__t_io_type;
+#define cma__c_max_io_type 2
+
+/*
+ * From our local :
+ *
+ * typedef long fd_mask;
+ *
+ * typedef struct fd_set {
+ * fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+ * } fd_set;
+ *
+ */
+typedef fd_mask cma__t_mask;
+typedef fd_set cma__t_file_mask;
+
+
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * Maximum number of files (ie, max_fd+1) as determined by getdtablesize().
+ */
+extern int cma__g_mx_file;
+
+/*
+ * Number of submasks (ie "int" sized chunks) per file descriptor mask as
+ * determined by getdtablesize().
+ */
+extern int cma__g_nspm;
+
+/*
+ * MACROS
+ */
+
+/*
+ * Define a constant for the errno value which indicates that the requested
+ * operation was not performed because it would block the process.
+ */
+# define cma__is_blocking(s) \
+ ((s == EAGAIN) || (s == EWOULDBLOCK) || (s == EINPROGRESS) || \
+ (s == EALREADY) || (s == EDEADLK))
+
+/*
+* It is necessary to issue an I/O function, before calling cma__io_wait()
+* in the following cases:
+*
+* * This file descriptor has been set non-blocking by CMA
+* * This file descriptor has been set non-blocking by the user.
+*/
+
+#define cma__issue_io_call(fd) \
+ ( (cma__g_file[fd]->non_blocking) || \
+ (cma__g_file[fd]->user_fl.user_non_blocking) )
+
+
+#define cma__set_user_nonblocking(flags) \
+
+/*
+ * Determine if the file is open
+ */
+/*
+ * If the file gets closed while waiting for the mutex cma__g_file[rfd]
+ * gets set to null. This results in a crash if NDEBUG is set to 0
+ * since cma__int_lock tries to dereference it to set the mutex ownership
+ * after it gets the mutex. The following will still set the ownership
+ * in cma__int_lock so we'll set it back to noone if cma__g_file is null
+ * when we come back just in case it matters. It shouldn't since its no
+ * longer in use but.....
+ * Callers of this should recheck cma__g_file after the reservation to
+ * make sure continueing makes sense.
+ */
+#define cma__fd_reserve(rfd) \
+ { \
+ cma__t_int_mutex *__mutex__; \
+ __mutex__ = cma__g_file[rfd]->mutex; \
+ cma__int_lock (__mutex__); \
+ if(cma__g_file[rfd] == (cma__t_file_obj *)cma_c_null_ptr) \
+ cma__int_unlock(__mutex__); \
+ }
+
+
+/*
+ * Unreserve a file descriptor
+ */
+#define cma__fd_unreserve(ufd) cma__int_unlock (cma__g_file[ufd]->mutex)
+
+/*
+ * AND together two select file descriptor masks
+ */
+#define cma__fdm_and(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] & (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Clear a bit in a select file descriptor mask
+ *
+ * FD_CLR(n, p) := ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_clr_bit(n,p) FD_CLR (n, p)
+
+/*
+ * Copy the contents of one file descriptor mask into another. If the
+ * destination operand is null, do nothing; if the source operand is null,
+ * simply zero the destination.
+ */
+#define cma__fdm_copy(src,dst,nfds) { \
+ if (dst) \
+ if (src) { \
+ cma__t_mask *__s__ = (cma__t_mask *)(src); \
+ cma__t_mask *__d__ = (cma__t_mask *)(dst); \
+ int __i__; \
+ for (__i__ = 0; __i__ < (nfds); __i__ += cma__c_nbpm) \
+ *__d__++ = *__s__++; \
+ } \
+ else \
+ cma__fdm_zero (dst); \
+ }
+
+/*
+ * To increment count for each bit set in fd - mask
+ */
+#define cma__fdm_count_bits(map,count) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) { \
+ cma__t_mask __tm__; \
+ __tm__ = (map)->fds_bits[__i__]; \
+ while(__tm__) { \
+ (count)++; \
+ __tm__ &= ~(__tm__ & (-__tm__)); /* Assumes 2's comp */ \
+ } \
+ } \
+ }
+
+/*
+ * Test if a bit is set in a select file descriptor mask
+ *
+ * FD_ISSET(n,p) := ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_is_set(n,p) FD_ISSET (n, p)
+
+/*
+ * OR together two select file descriptor masks
+ */
+#define cma__fdm_or(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] | (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Set a bit in a select file descriptor mask
+ *
+ * FD_SET(n,p) := ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_set_bit(n,p) FD_SET (n, p)
+
+/*
+ * Clear a select file descriptor mask.
+ */
+#define cma__fdm_zero(n) \
+ cma__memset ((char *) n, 0, cma__g_nspm * sizeof(cma__t_mask))
+
+
+
+
+
+/*
+ * CMA "thread-synchronous" I/O read/write operations
+ */
+
+ /*
+ * Since all CMA "thread-synchronous" I/O (read or write) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Check that the file descriptor is a legitimate value.
+ * 2. Check that the entry in the CMA file "database" which corresponds to
+ * the file descriptor indicates that the "file" was "opened" by CMA.
+ * 3. Reserve the file, to serialized access to files. This not only
+ * simplifies things, but also defends against non-reentrancy.
+ * 4. If the "file" is "set" for non-blocking I/O, check if we
+ * have actually set the file non-blocking yet, and if not do so.
+ * Then, issue the I/O operantion.
+ * Success or failure is returned immediately, after unreserving the
+ * file. If the error indicates that the operation would have caused
+ * the process to block, continue to the next step.
+ * 5. The I/O prolog adds this "file" to the global bit mask, which
+ * represents all "files" which have threads waiting to perform I/O on
+ * them, and causes the thread to block on the condition variable for
+ * this "file". Periodically, a select is done on this global bit
+ * mask, and the condition variables corresponding to "files" which
+ * are ready for I/O are signaled, releasing those waiting threads to
+ * perform their I/O.
+ * 6. When the thread returns from the I/O prolog, it can (hopefully)
+ * perform its operation without blocking the process.
+ * 7. The I/O epilog clears the bit in the global mask and/or signals the
+ * the next thread waiting for this "file", as appropriate.
+ * 8. If the I/O failed, continue to loop.
+ * 9. Finally, the "file" is unreserved, as we're done with it, and the
+ * result of the operation is returned.
+ *
+ *
+ * Note: currently, we believe that timeslicing which is based on the
+ * virtual-time timer does not cause system calls to return EINTR.
+ * Threfore, any EINTR returns are relayed directly to the caller.
+ * On platforms which do not support a virtual-time timer, the code
+ * should probably catch EINTR returns and restart the system call.
+ */
+
+/*
+ * This macro is used for both read-type and write-type functions.
+ *
+ * Note: the second call to "func" may require being bracketed in a
+ * cma__interrupt_disable/cma__interrupt_enable pair, but we'll
+ * wait and see if this is necessary.
+ */
+#define cma__ts_func(func,fd,arglist,type,post_process) { \
+ cma_t_integer __res__; \
+ cma_t_boolean __done__ = cma_c_false; \
+ if ((fd < 0) || (fd >= cma__g_mx_file)) return (cma__set_errno (EBADF), -1); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ cma__fd_reserve (fd); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ if (cma__issue_io_call(fd)) {\
+ if ((!cma__g_file[fd]->set_non_blocking) && \
+ (cma__g_file[fd]->non_blocking == cma_c_true)) \
+ cma__set_nonblocking(fd); \
+ cma__interrupt_disable (0); \
+ TRY { \
+ __res__ = func arglist; \
+ } \
+ CATCH_ALL { \
+ cma__interrupt_enable (0); \
+ cma__fd_unreserve (fd); \
+ RERAISE; \
+ } \
+ ENDTRY \
+ cma__interrupt_enable (0); \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ if (__done__) { \
+ cma__fd_unreserve (fd); \
+ } \
+ else { \
+ TRY { \
+ cma__io_prolog (type, fd); \
+ while (!__done__) { \
+ cma__io_wait (type, fd); \
+ __res__ = func arglist; \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ } \
+ FINALLY { \
+ cma__io_epilog (type, fd); \
+ cma__fd_unreserve (fd); \
+ } \
+ ENDTRY \
+ } \
+ if (__res__ != -1) post_process; \
+ return __res__; \
+ }
+
+ /*
+ * Since most CMA "thread-synchronous" I/O ("open"-type) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Issue the open function.
+ * 2. If the value returned indicates an error, return it to the caller.
+ * 3. If the file descriptor returned is larger than what we think is the
+ * maximum value (ie if it is too big for our database) then bugcheck.
+ * 4. "Open" the "file" in the CMA file database.
+ * 5. Return the file descriptor value to the caller.
+ *
+ * FIX-ME: for the time being, if the I/O operation returns EINTR, we
+ * simply return it to the caller; eventually, we should catch this
+ * and "do the right thing" (if we can figure out what that is).
+ */
+
+/*
+ * This macro is used for all "open"-type functions which return a single file
+ * desciptor by immediate value.
+ */
+#define cma__ts_open(func,arglist,post_process) { \
+ int __fd__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __fd__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__fd__ >= 0 && __fd__ < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __fd__ = -1; \
+ } \
+ ENDTRY \
+ if (__fd__ >= cma__g_mx_file) \
+ cma__bugcheck ("cma__ts_open: fd is too large"); \
+ return __fd__; \
+ }
+/*
+ * This macro is used for all "open"-type functions which return a pair of file
+ * desciptors by reference parameter.
+ */
+#define cma__ts_open2(func,fdpair,arglist,post_process) { \
+ int __res__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __res__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__res__ >= 0 && fdpair[0] < cma__g_mx_file \
+ && fdpair[1] < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __res__ = -1; \
+ } \
+ ENDTRY \
+ if ((fdpair[0] >= cma__g_mx_file) || (fdpair[1] >= cma__g_mx_file)) \
+ cma__bugcheck ("cma__ts_open2: one of fd's is too large"); \
+ return __res__; \
+ }
+
+/*
+ * INTERNAL INTERFACES
+ */
+extern void cma__close_general (int);
+
+extern void cma__init_thread_io (void);
+
+extern cma_t_boolean cma__io_available (cma__t_io_type,int,struct timeval *);
+
+extern void cma__io_epilog (cma__t_io_type,int);
+
+extern void cma__io_prolog (cma__t_io_type,int);
+
+extern void cma__io_wait (cma__t_io_type,int);
+
+extern void cma__open_general (int);
+
+extern void cma__reinit_thread_io (int);
+
+extern void cma__set_nonblocking (int);
+
+extern void cma__set_user_nonblock_flags (int,int);
+
+extern cma_t_boolean cma__is_open (int);
+
+#endif
HP800/cma_thread_io.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_handle.h
===================================================================
--- cma_handle.h (nonexistent)
+++ cma_handle.h (revision 513)
@@ -0,0 +1,182 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for handles
+ */
+
+#ifndef CMA_HANDLE
+#define CMA_HANDLE
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma__validate_attr(handle) \
+ ((cma__t_int_attr *)cma__validate_handle ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_attr))
+
+#define cma__validate_cv(handle) \
+ ((cma__t_int_cv *)cma__validate_handle ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_cv))
+
+#define cma__validate_mutex(handle) \
+ ((cma__t_int_mutex *)cma__validate_handle ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_mutex))
+
+#define cma__validate_tcb(handle) \
+ ((cma__t_int_tcb *)cma__validate_handle ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_tcb))
+
+#define cma__validate_stack(handle) \
+ ((cma__t_int_stack *)cma__validate_handle ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_stack))
+
+#define cma__validate_null_attr(handle) \
+ ((cma__t_int_attr *)cma__validate_handle_null ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_attr))
+
+#define cma__validate_null_cv(handle) \
+ ((cma__t_int_cv *)cma__validate_handle_null ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_cv))
+
+#define cma__validate_null_mutex(handle) \
+ ((cma__t_int_mutex *)cma__validate_handle_null ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_mutex))
+
+#define cma__validate_null_tcb(handle) \
+ ((cma__t_int_tcb *)cma__validate_handle_null ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_tcb))
+
+#define cma__validate_null_stack(handle) \
+ ((cma__t_int_stack *)cma__validate_handle_null ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_stack))
+
+#define cma__val_attr_stat(handle,obj) \
+ cma__val_hand_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_attr, \
+ (cma__t_object **)obj)
+
+#define cma__val_cv_stat(handle,obj) \
+ cma__val_hand_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_cv, \
+ (cma__t_object **)obj)
+
+#define cma__val_mutex_stat(handle,obj) \
+ cma__val_hand_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_mutex, \
+ (cma__t_object **)obj)
+
+#define cma__val_tcb_stat(handle) \
+ cma__val_hand_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_tcb, \
+ (cma__t_object **)obj)
+
+#define cma__val_stack_stat(handle,obj) \
+ cma__val_hand_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_stack, \
+ (cma__t_object **)obj)
+
+#define cma__val_nullattr_stat(handle,obj) \
+ cma__val_handnull_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_attr, \
+ (cma__t_object **)obj)
+
+#define cma__val_nullcv_stat(handle,obj) \
+ cma__val_handnull_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_cv, \
+ (cma__t_object **)obj)
+
+#define cma__val_nullmutex_stat(handle,obj) \
+ cma__val_handnull_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_mutex, \
+ (cma__t_object **)obj)
+
+#define cma__val_nulltcb_stat(handle,obj) \
+ cma__val_handnull_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_tcb, \
+ (cma__t_object **)obj)
+
+#define cma__val_nullstack_stat(handle) \
+ cma__val_handnull_stat ( \
+ (cma_t_handle *)(handle), \
+ cma__c_obj_stack, \
+ (cma__t_object **)obj)
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * Internal format of a handle (to the outside world it's an array of two
+ * addresses, but we know better).
+ */
+typedef struct CMA__T_INT_HANDLE {
+ cma__t_object *pointer; /* Address of internal structure */
+ cma__t_short sequence; /* Sequence number of object */
+ cma__t_short type; /* Type code of object */
+ } cma__t_int_handle;
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void cma__clear_handle (cma_t_handle *);
+
+extern void cma__object_to_handle (cma__t_object *,cma_t_handle *);
+
+extern cma__t_int_attr * cma__validate_default_attr (cma_t_handle *);
+
+extern cma_t_status cma__val_defattr_stat (cma_t_handle *,cma__t_int_attr **);
+
+extern cma__t_object * cma__validate_handle (cma_t_handle *,cma_t_natural );
+
+extern cma_t_status cma__val_hand_stat (cma_t_handle *,cma_t_natural,cma__t_object **);
+
+extern cma__t_object *cma__validate_handle_null (cma_t_handle *,cma_t_natural);
+
+extern cma_t_status cma__val_handnull_stat (cma_t_handle *,cma_t_natural,cma__t_object **);
+
+#endif
cma_handle.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: AT386/cma_thread_io.h
===================================================================
--- AT386/cma_thread_io.h (nonexistent)
+++ AT386/cma_thread_io.h (revision 513)
@@ -0,0 +1,457 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for thread synchrounous I/O
+ */
+
+#ifndef CMA_THREAD_IO
+#define CMA_THREAD_IO
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS
+ */
+
+/*
+ * Define symbols which indicate whether to compile code for obsolete
+ * "non-blocking mode" flags: FNDELAY and FNBLOCK. If the obsolete
+ * symbols are defined, and if their replacement symbols are defined
+ * and are different or if they are undefined, then define a symbol
+ * that says to compile the code in; otherwise no code will be compiled
+ * for these obsolete symbols.
+ */
+#ifdef FNDELAY
+# ifdef O_NDELAY
+# if O_NDELAY != FNDELAY
+# define _CMA_FNDELAY_
+# endif
+# else
+# define _CMA_FNDELAY_
+# endif
+#endif
+
+#ifdef FNBLOCK
+# ifdef O_NONBLOCK
+# if O_NONBLOCK != FNBLOCK
+# define _CMA_FNBLOCK_
+# endif
+# else
+# define _CMA_FNBLOCK_
+# endif
+#endif
+
+
+extern cma_t_boolean cma_is_open(int);
+/*
+ * Maximum number of files (ie, max_fd+1)
+ */
+#define cma__c_mx_file FD_SETSIZE
+
+/*
+ * Number of bits per file descriptor bit mask (ie number of bytes * bits/byte)
+ */
+#define cma__c_nbpm NFDBITS
+
+/*
+ * TYPE DEFINITIONS
+ */
+
+typedef enum CMA__T_IO_TYPE {
+ cma__c_io_read = 0,
+ cma__c_io_write = 1,
+ cma__c_io_except = 2
+ } cma__t_io_type;
+#define cma__c_max_io_type 2
+
+/*
+ * From our local :
+ *
+ * typedef long fd_mask;
+ *
+ * typedef struct fd_set {
+ * fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+ * } fd_set;
+ *
+ */
+typedef fd_mask cma__t_mask;
+typedef fd_set cma__t_file_mask;
+
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * Maximum number of files (ie, max_fd+1) as determined by getdtablesize().
+ */
+extern int cma__g_mx_file;
+
+/*
+ * Number of submasks (ie "int" sized chunks) per file descriptor mask as
+ * determined by getdtablesize().
+ */
+extern int cma__g_nspm;
+
+/*
+ * MACROS
+ */
+
+/*
+ * Define a constant for the errno value which indicates that the requested
+ * operation was not performed because it would block the process.
+ */
+# define cma__is_blocking(s) \
+ ((s == EAGAIN) || (s == EWOULDBLOCK) || (s == EINPROGRESS) || \
+ (s == EALREADY) || (s == EDEADLK))
+
+/*
+* It is necessary to issue an I/O function, before calling cma__io_wait()
+* in the following cases:
+*
+* * This file descriptor has been set non-blocking by CMA
+* * This file descriptor has been set non-blocking by the user.
+*/
+
+#define cma__issue_io_call(fd) \
+ ( (cma__g_file[fd]->non_blocking) || \
+ (cma__g_file[fd]->user_fl.user_non_blocking) )
+
+
+#define cma__set_user_nonblocking(flags) \
+
+/*
+ * Determine if the file is open
+ */
+/*
+ * If the file gets closed while waiting for the mutex cma__g_file[rfd]
+ * gets set to null. This results in a crash if NDEBUG is set to 0
+ * since cma__int_lock tries to dereference it to set the mutex ownership
+ * after it gets the mutex. The following will still set the ownership
+ * in cma__int_lock so we'll set it back to noone if cma__g_file is null
+ * when we come back just in case it matters. It shouldn't since its no
+ * longer in use but.....
+ * Callers of this should recheck cma__g_file after the reservation to
+ * make sure continueing makes sense.
+ */
+#define cma__fd_reserve(rfd) \
+ { \
+ cma__t_int_mutex *__mutex__; \
+ __mutex__ = cma__g_file[rfd]->mutex; \
+ cma__int_lock (__mutex__); \
+ if(cma__g_file[rfd] == (cma__t_file_obj *)cma_c_null_ptr) \
+ cma__int_unlock(__mutex__); \
+ }
+
+
+/*
+ * Unreserve a file descriptor
+ */
+#define cma__fd_unreserve(ufd) cma__int_unlock (cma__g_file[ufd]->mutex)
+
+/*
+ * AND together two select file descriptor masks
+ */
+#define cma__fdm_and(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] & (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Clear a bit in a select file descriptor mask
+ *
+ * FD_CLR(n, p) := ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_clr_bit(n,p) FD_CLR (n, p)
+
+/*
+ * Copy the contents of one file descriptor mask into another. If the
+ * destination operand is null, do nothing; if the source operand is null,
+ * simply zero the destination.
+ */
+#define cma__fdm_copy(src,dst,nfds) { \
+ if (dst) \
+ if (src) { \
+ cma__t_mask *__s__ = (cma__t_mask *)(src); \
+ cma__t_mask *__d__ = (cma__t_mask *)(dst); \
+ int __i__; \
+ for (__i__ = 0; __i__ < (nfds); __i__ += cma__c_nbpm) \
+ *__d__++ = *__s__++; \
+ } \
+ else \
+ cma__fdm_zero (dst); \
+ }
+
+/*
+ * To increment count for each bit set in fd - mask
+ */
+#define cma__fdm_count_bits(map,count) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) { \
+ cma__t_mask __tm__; \
+ __tm__ = (map)->fds_bits[__i__]; \
+ while(__tm__) { \
+ (count)++; \
+ __tm__ &= ~(__tm__ & (-__tm__)); /* Assumes 2's comp */ \
+ } \
+ } \
+ }
+
+/*
+ * Test if a bit is set in a select file descriptor mask
+ *
+ * FD_ISSET(n,p) := ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_is_set(n,p) FD_ISSET (n, p)
+
+/*
+ * OR together two select file descriptor masks
+ */
+#define cma__fdm_or(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] | (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Set a bit in a select file descriptor mask
+ *
+ * FD_SET(n,p) := ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_set_bit(n,p) FD_SET (n, p)
+
+/*
+ * Clear a select file descriptor mask.
+ */
+#define cma__fdm_zero(n) \
+ cma__memset ((char *) n, 0, cma__g_nspm * sizeof(cma__t_mask))
+
+
+
+/*
+ * CMA "thread-synchronous" I/O read/write operations
+ */
+
+ /*
+ * Since all CMA "thread-synchronous" I/O (read or write) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Check that the file descriptor is a legitimate value.
+ * 2. Check that the entry in the CMA file "database" which corresponds to
+ * the file descriptor indicates that the "file" was "opened" by CMA.
+ * 3. Reserve the file, to serialized access to files. This not only
+ * simplifies things, but also defends against non-reentrancy.
+ * 4. If the "file" is "set" for non-blocking I/O, check if we
+ * have actually set the file non-blocking yet, and if not do so.
+ * Then, issue the I/O operantion.
+ * Success or failure is returned immediately, after unreserving the
+ * file. If the error indicates that the operation would have caused
+ * the process to block, continue to the next step.
+ * 5. The I/O prolog adds this "file" to the global bit mask, which
+ * represents all "files" which have threads waiting to perform I/O on
+ * them, and causes the thread to block on the condition variable for
+ * this "file". Periodically, a select is done on this global bit
+ * mask, and the condition variables corresponding to "files" which
+ * are ready for I/O are signaled, releasing those waiting threads to
+ * perform their I/O.
+ * 6. When the thread returns from the I/O prolog, it can (hopefully)
+ * perform its operation without blocking the process.
+ * 7. The I/O epilog clears the bit in the global mask and/or signals the
+ * the next thread waiting for this "file", as appropriate.
+ * 8. If the I/O failed, continue to loop.
+ * 9. Finally, the "file" is unreserved, as we're done with it, and the
+ * result of the operation is returned.
+ *
+ *
+ * Note: currently, we believe that timeslicing which is based on the
+ * virtual-time timer does not cause system calls to return EINTR.
+ * Threfore, any EINTR returns are relayed directly to the caller.
+ * On platforms which do not support a virtual-time timer, the code
+ * should probably catch EINTR returns and restart the system call.
+ */
+
+/*
+ * This macro is used for both read-type and write-type functions.
+ *
+ * Note: the second call to "func" may require being bracketed in a
+ * cma__interrupt_disable/cma__interrupt_enable pair, but we'll
+ * wait and see if this is necessary.
+ */
+#define cma__ts_func(func,fd,arglist,type,post_process) { \
+ cma_t_integer __res__; \
+ cma_t_boolean __done__ = cma_c_false; \
+ if ((fd < 0) || (fd >= cma__g_mx_file)) return (cma__set_errno (EBADF), -1); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ cma__fd_reserve (fd); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ if (cma__issue_io_call(fd)) {\
+ if ((!cma__g_file[fd]->set_non_blocking) && \
+ (cma__g_file[fd]->non_blocking == cma_c_true)) \
+ cma__set_nonblocking(fd); \
+ cma__interrupt_disable (0); \
+ TRY { \
+ __res__ = func arglist; \
+ } \
+ CATCH_ALL { \
+ cma__interrupt_enable (0); \
+ cma__fd_unreserve (fd); \
+ RERAISE; \
+ } \
+ ENDTRY \
+ cma__interrupt_enable (0); \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ if (__done__) { \
+ cma__fd_unreserve (fd); \
+ } \
+ else { \
+ TRY { \
+ cma__io_prolog (type, fd); \
+ while (!__done__) { \
+ cma__io_wait (type, fd); \
+ __res__ = func arglist; \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ } \
+ FINALLY { \
+ cma__io_epilog (type, fd); \
+ cma__fd_unreserve (fd); \
+ } \
+ ENDTRY \
+ } \
+ if (__res__ != -1) post_process; \
+ return __res__; \
+ }
+
+ /*
+ * Since most CMA "thread-synchronous" I/O ("open"-type) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Issue the open function.
+ * 2. If the value returned indicates an error, return it to the caller.
+ * 3. If the file descriptor returned is larger than what we think is the
+ * maximum value (ie if it is too big for our database) then bugcheck.
+ * 4. "Open" the "file" in the CMA file database.
+ * 5. Return the file descriptor value to the caller.
+ *
+ * FIX-ME: for the time being, if the I/O operation returns EINTR, we
+ * simply return it to the caller; eventually, we should catch this
+ * and "do the right thing" (if we can figure out what that is).
+ */
+
+/*
+ * This macro is used for all "open"-type functions which return a single file
+ * desciptor by immediate value.
+ */
+#define cma__ts_open(func,arglist,post_process) { \
+ int __fd__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __fd__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__fd__ >= 0 && __fd__ < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __fd__ = -1; \
+ } \
+ ENDTRY \
+ if (__fd__ >= cma__g_mx_file) \
+ cma__bugcheck ("cma__ts_open: fd is too large"); \
+ return __fd__; \
+ }
+/*
+ * This macro is used for all "open"-type functions which return a pair of file
+ * desciptors by reference parameter.
+ */
+#define cma__ts_open2(func,fdpair,arglist,post_process) { \
+ int __res__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __res__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__res__ >= 0 && fdpair[0] < cma__g_mx_file \
+ && fdpair[1] < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __res__ = -1; \
+ } \
+ ENDTRY \
+ if ((fdpair[0] >= cma__g_mx_file) || (fdpair[1] >= cma__g_mx_file)) \
+ cma__bugcheck ("cma__ts_open2: one of fd's is too large"); \
+ return __res__; \
+ }
+
+/*
+ * INTERNAL INTERFACES
+ */
+extern void cma__close_general (int);
+
+extern void cma__init_thread_io (void);
+
+extern cma_t_boolean cma__io_available (cma__t_io_type,int,struct timeval *);
+
+extern void cma__io_epilog (cma__t_io_type,int);
+
+extern void cma__io_prolog (cma__t_io_type,int);
+
+extern void cma__io_wait (cma__t_io_type,int);
+
+extern void cma__open_general (int);
+
+extern void cma__reinit_thread_io (int);
+
+extern void cma__set_nonblocking (int);
+
+extern void cma__set_user_nonblock_flags (int,int);
+
+extern cma_t_boolean cma__is_open (int);
+
+
+#endif
AT386/cma_thread_io.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_deb_core.h
===================================================================
--- cma_deb_core.h (nonexistent)
+++ cma_deb_core.h (revision 513)
@@ -0,0 +1,164 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * This file defines the internal interface to the core of CMA
+ * debugging services. (The client interface to debugging services
+ * is provided by cma_debug_client.h).
+ */
+
+#ifndef CMA_DEB_CORE
+#define CMA_DEB_CORE
+
+/*
+ * INCLUDE FILES
+ */
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+
+/*
+ * TYPEDEFS
+ */
+
+/*FIX-ME* Need to use sizes that are platform specific */
+typedef long int cma___t_debug_ctx[17];
+
+/*
+ * Type defing the format of known object lists
+ */
+typedef struct CMA__T_KNOWN_OBJECT {
+ cma__t_queue queue; /* Queue header for known objects */
+ cma__t_int_mutex *mutex; /* Mutex to control access to queue */
+ } cma__t_known_object;
+
+
+/*
+ * Type defining the registration for one debug client (e.g. Ada)
+ */
+typedef struct CMA__T_DEB_REGISTRY {
+ cma_t_address entry; /* Client's debug entry point */
+ cma_t_key key; /* Client's context key */
+ cma_t_integer fac; /* Client's debug facility number */
+ cma_t_boolean has_prolog; /* Client's TCBs have std prolog */
+ } cma__t_deb_registry;
+
+#define cma__c_deb_max_clients 10
+
+/*
+ * Type defining the global debugging state for all threads.
+ */
+typedef struct CMA__T_DEBUG_STATE {
+ /*
+ * The following flag is set if changes were made while in the
+ * debugger that may make the ready lists inconsistent. For
+ * example, if a thread priority is changed in the debugger, the
+ * thread is not moved between queues. Making things consistent
+ * is deferred to when the dispatcher is next invoked -- which we
+ * try to make very soon.
+ */
+ cma_t_boolean is_inconsistency; /* Ready lists are inconsistent */
+
+
+ cma_t_boolean events_enabled; /* Set if _any_ event is enabled */
+ cma_t_boolean flags[cma__c_debevt__dim];
+ /* Which events are enabled */
+ cma__t_int_tcb *next_to_run; /* TCB of thread to run next */
+
+ cma__t_int_mutex *mutex; /* Mutex for registering clients */
+ cma_t_integer client_count; /* Count of debug clients */
+ cma__t_deb_registry clients[cma__c_deb_max_clients+1];
+ /* Array of current debug clients */
+ } cma__t_debug_state;
+
+
+/*
+ * Routine that will symbolize and address and print it.
+ */
+typedef void (*cma__t_print_symbol) (cma_t_address);
+
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * Variable holding the global debugging state
+ *
+ * (This is primarily written by the debugger interface and read
+ * by the thread dispatcher).
+ */
+extern cma__t_debug_state cma__g_debug_state;
+
+/*
+ * Known object queues
+ */
+extern cma__t_known_object cma__g_known_atts;
+extern cma__t_known_object cma__g_known_cvs;
+extern cma__t_known_object cma__g_known_mutexes;
+extern cma__t_known_object cma__g_known_threads;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+/* Get information while in debugger context */
+extern void cma__deb_get
+ (cma__t_int_tcb *,cma_t_debug_get,cma_t_address,cma_t_integer,cma_t_integer);
+
+/* Set information while in debugger context */
+extern void cma__deb_set (cma__t_int_tcb *,cma_t_debug_set,cma_t_address,cma_t_integer);
+
+extern void cma__init_debug (void);
+
+extern void cma__reinit_debug (cma_t_integer);
+
+extern void cma__deb_anytcb_to_tcb (cma_t_tcb_header *,cma__t_int_tcb **);
+
+extern void cma__deb_fac_to_client (cma_t_integer,cma_t_key *);
+
+extern void cma__deb_get_client_info (cma_t_key,cma_t_address *,cma_t_boolean *);
+
+extern void cma__deb_get_context (cma__t_int_tcb *,cma_t_key,cma_t_address *);
+
+extern cma__t_int_tcb *cma__deb_get_self_tcb (void);
+
+extern void cma__deb_get_time_slice (cma_t_interval *);
+
+extern cma__t_int_tcb *cma__deb_next_tcb
+ (cma__t_int_tcb *,cma_t_integer *,cma_t_integer *,cma_t_boolean *);
+
+extern cma_t_boolean cma__deb_set_alert (cma__t_int_tcb *);
+
+extern void cma__deb_set_next_thread (cma__t_int_tcb *);
+
+extern void cma__deb_set_force_dispatch (cma_t_address );
+
+extern void cma__deb_set_time_slice (cma_t_interval);
+
+extern void cma__deb_show_thread
+ (cma__t_int_tcb *,cma_t_boolean,cma_t_boolean,cma___t_debug_ctx,cma__t_eol_routine,
+ cma__t_eol_routine,cma__t_print_symbol);
+
+extern void
+cma__deb_show_stats (cma__t_int_tcb *,cma_t_boolean,cma_t_boolean,cma__t_eol_routine,cma__t_eol_routine,cma__t_print_symbol);
+#endif
cma_deb_core.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_mutex.h
===================================================================
--- cma_mutex.h (nonexistent)
+++ cma_mutex.h (revision 513)
@@ -0,0 +1,230 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for mutex operations
+ */
+
+#ifndef CMA_MUTEX
+#define CMA_MUTEX
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+/*
+ * TYPEDEFS
+ */
+
+typedef struct CMA__T_INT_MUTEX {
+ cma__t_object header; /* Common header (sequence, type) */
+ cma__t_int_attr *attributes; /* Back link */
+ cma__t_int_tcb *owner; /* Current owner (if any) */
+ cma_t_integer nest_count; /* Nesting level for recursive mutex */
+ cma__t_atomic_bit *unlock; /* Pointer used for unlock operation */
+ cma__t_atomic_bit lock; /* Set if currently locked */
+ struct CMA__T_INT_MUTEX *int_lock; /* Internal protection for mutex */
+ cma__t_atomic_bit event; /* Clear when unlock requires action */
+ cma__t_atomic_bit waiters; /* Clear when threads are waiting */
+ cma__t_atomic_bit bitbucket; /* Fake bit to keep friendlies locked */
+ cma_t_mutex_kind mutex_kind; /* Kind of mutex */
+ cma__t_semaphore semaphore; /* Semaphore for low-level wait */
+ } cma__t_int_mutex;
+
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * Lock a mutex (internal)
+ *
+ * FORMAL PARAMETERS:
+ *
+ * mutex Pointer to mutex object to lock
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * none
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#ifdef NDEBUG
+# define cma__int_lock(mutex) { \
+ if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \
+ cma_t_status res;\
+ res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \
+ if (res != cma_s_normal) cma__error (res); \
+ } \
+ }
+#else
+# define cma__int_lock(mutex) { \
+ cma__t_int_tcb *__ltcb__; \
+ __ltcb__ = cma__get_self_tcb (); \
+ if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \
+ cma_t_status res;\
+ res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \
+ if (res != cma_s_normal) cma__error (res); \
+ } \
+ ((cma__t_int_mutex *)mutex)->owner = __ltcb__; \
+ }
+#endif
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * Unlock a mutex (internal)
+ *
+ * FORMAL PARAMETERS:
+ *
+ * mutex Pointer to mutex object to unlock
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * none
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#ifdef NDEBUG
+# define cma__int_unlock(mutex) { \
+ cma__unset (((cma__t_int_mutex *)mutex)->unlock); \
+ if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \
+ cma_t_status res;\
+ res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \
+ if (res != cma_s_normal) cma__error (res); \
+ } \
+ }
+#else
+# define cma__int_unlock(mutex) { \
+ cma__t_int_tcb *__utcb__; \
+ __utcb__ = cma__get_self_tcb (); \
+ if (((cma__t_int_mutex *)mutex)->mutex_kind == cma_c_mutex_fast) { \
+ cma__assert_warn ( \
+ (__utcb__ == ((cma__t_int_mutex *)mutex)->owner), \
+ "attempt to release mutx owned by another thread"); \
+ ((cma__t_int_mutex *)mutex)->owner = (cma__t_int_tcb *)cma_c_null_ptr; \
+ } \
+ cma__unset (((cma__t_int_mutex *)mutex)->unlock); \
+ if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \
+ cma_t_status res;\
+ res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \
+ if (res != cma_s_normal) cma__error (res); \
+ } \
+ }
+#endif
+
+/*
+ * FUNCTIONAL DESCRIPTION:
+ *
+ * cma__int_mutex_delete - Performs work for cma_mutex_delete
+ *
+ * FORMAL PARAMETERS:
+ *
+ * cma__t_mutex _mutex_ - Mutex to be deleted
+ *
+ * IMPLICIT INPUTS:
+ *
+ * none
+ *
+ * IMPLICIT OUTPUTS:
+ *
+ * none
+ *
+ * FUNCTION VALUE:
+ *
+ * none
+ *
+ * SIDE EFFECTS:
+ *
+ * none
+ */
+#define cma__int_mutex_delete(_mutex_) { \
+ cma__t_int_mutex *_int_mutex_; \
+ _int_mutex_ = cma__validate_null_mutex (_mutex_); \
+ if (_int_mutex_ == (cma__t_int_mutex *)cma_c_null_ptr) \
+ return; \
+ if (cma__int_mutex_locked (_int_mutex_)) \
+ cma__error (cma_s_in_use); \
+ cma__free_mutex (_int_mutex_); \
+ cma__clear_handle (_mutex_); \
+ }
+
+
+/*
+ * GLOBAL DATA
+ */
+
+extern cma__t_sequence cma__g_mutex_seq;
+extern cma__t_int_mutex *cma__g_global_lock;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void cma__destroy_mutex (cma__t_int_mutex *);
+
+extern void cma__free_mutex (cma__t_int_mutex *);
+
+extern void cma__free_mutex_nolock (cma__t_int_mutex *);
+
+extern cma__t_int_mutex * cma__get_first_mutex (cma__t_int_attr *);
+
+extern cma__t_int_mutex * cma__get_mutex (cma__t_int_attr *);
+
+extern void cma__init_mutex (void);
+
+extern cma_t_status cma__int_mutex_block (cma__t_int_mutex *);
+
+extern cma_t_boolean cma__int_mutex_locked (cma__t_int_mutex *);
+
+extern cma_t_boolean cma__int_try_lock (cma__t_int_mutex *);
+
+extern cma_t_status cma__int_mutex_unblock (cma__t_int_mutex *);
+
+extern cma_t_boolean cma__mutex_locked (cma_t_mutex);
+
+extern void cma__reinit_mutex (cma_t_integer);
+
+#endif
cma_mutex.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_init.h
===================================================================
--- cma_init.h (nonexistent)
+++ cma_init.h (revision 513)
@@ -0,0 +1,114 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for CMA initialization
+ */
+
+#ifndef CMA_INIT
+#define CMA_INIT
+
+/*
+ * INCLUDE FILES
+ */
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#define cma__c_env_maxattr 0
+#define cma__c_env_minattr 1
+#define cma__c_env_maxcond 2
+#define cma__c_env_mincond 3
+#define cma__c_env_maxmutex 4
+#define cma__c_env_minmutex 5
+#define cma__c_env_maxthread 6
+#define cma__c_env_minthread 7
+#define cma__c_env_maxcluster 8
+#define cma__c_env_mincluster 9
+#define cma__c_env_maxvp 10
+#define cma__c_env_multiplex 11
+#define cma__c_env_trace 12
+#define cma__c_env_trace_file 13
+
+#define cma__c_env_count 13
+
+
+/*
+ * cma__int_init
+ *
+ * Initialize the main body of CMA exactly once.
+ *
+ * We raise an exception if, for some odd reason, there are already threads
+ * in the environment (e.g. kernel threads), and one of them is trying to
+ * initialize CMA before the first thread got all the way through the actual
+ * initialization. This code maintains the invariants: "after successfully
+ * calling CMA_INIT, you can call any CMA function", and "CMA is actually
+ * initialized at most once".
+ */
+/*#ifndef _HP_LIBC_R */
+
+#if defined _HP_LIBC_R ||(defined(SNI_SVR4) && !defined(CMA_INIT_NEEDED))
+# define cma__int_init()
+#else
+# define cma__int_init() { \
+ if (!cma__tac_isset(&cma__g_init_started)) { \
+ if (!cma__test_and_set (&cma__g_init_started)) { \
+ cma__init_static (); \
+ cma__test_and_set (&cma__g_init_done); \
+ } \
+ else if (!cma__tac_isset (&cma__g_init_done)) { \
+ cma__error (cma_s_inialrpro); \
+ }}}
+#endif
+
+/*
+ * TYPEDEFS
+ */
+
+typedef enum CMA__T_ENV_TYPE {
+ cma__c_env_type_int,
+ cma__c_env_type_file
+ } cma__t_env_type;
+
+typedef struct CMA__T_ENV {
+ char *name; /* Name of environment variable */
+ cma__t_env_type type; /* Type of variable */
+ cma_t_integer value; /* Numeric value of the variable */
+ } cma__t_env;
+
+/*
+ * GLOBAL DATA
+ */
+
+extern cma__t_env cma__g_env[cma__c_env_count];
+extern cma__t_atomic_bit cma__g_init_started;
+extern cma__t_atomic_bit cma__g_init_done;
+extern char *cma__g_version;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void
+cma__init_static (void); /* Initialize static data */
+
+#if _CMA_OS_ != _CMA__VMS
+extern void cma__init_atfork (void);
+#endif
+
+#endif
cma_init.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_stack.h
===================================================================
--- cma_stack.h (nonexistent)
+++ cma_stack.h (revision 513)
@@ -0,0 +1,83 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for stack management
+ */
+#ifndef CMA_STACK
+#define CMA_STACK
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+#if _CMA_UNIPROCESSOR_
+# define cma__get_self_tcb() (cma__g_current_thread)
+#endif
+
+/*
+ * Round the given value (a) upto cma__g_chunk_size
+ */
+#define cma__roundup_chunksize(a) (cma__roundup(a,cma__g_chunk_size))
+
+/*
+ * TYPEDEFS
+ */
+
+/*
+ * GLOBAL DATA
+ */
+
+extern cma__t_list cma__g_stack_clusters;
+extern cma__t_int_tcb *cma__g_current_thread;
+extern cma_t_integer cma__g_chunk_size;
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern void cma__assign_stack (cma__t_int_stack *,cma__t_int_tcb *);
+
+extern void cma__free_stack (cma__t_int_stack *);
+
+extern void cma__free_stack_list (cma__t_queue *);
+
+#if !_CMA_UNIPROCESSOR_
+extern cma__t_int_tcb * cma__get_self_tcb (void);
+#endif
+
+extern cma__t_int_tcb * cma__get_sp_tcb (cma_t_address);
+
+extern cma__t_int_stack * cma__get_stack (cma__t_int_attr *);
+
+extern void cma__init_stack (void);
+
+extern void cma__reinit_stack (cma_t_integer);
+
+#if _CMA_PROTECT_MEMORY_
+extern void cma__remap_stack_holes (void);
+#endif
+
+#endif
cma_stack.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: RIOS/cma_thread_io.h
===================================================================
--- RIOS/cma_thread_io.h (nonexistent)
+++ RIOS/cma_thread_io.h (revision 513)
@@ -0,0 +1,434 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for thread synchrounous I/O
+ */
+
+#ifndef CMA_THREAD_IO
+#define CMA_THREAD_IO
+
+/*
+ * INCLUDE FILES
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/*
+ * CONSTANTS
+ */
+
+/*
+ * Maximum number of files (ie, max_fd+1)
+ */
+#define cma__c_mx_file FD_SETSIZE
+
+/*
+ * Number of bits per file descriptor bit mask (ie number of bytes * bits/byte)
+ */
+#define cma__c_nbpm NFDBITS
+
+/*
+ * TYPE DEFINITIONS
+ */
+
+typedef enum CMA__T_IO_TYPE {
+ cma__c_io_read = 0,
+ cma__c_io_write = 1,
+ cma__c_io_except = 2
+ } cma__t_io_type;
+#define cma__c_max_io_type 2
+
+/*
+ * From our local :
+ *
+ * typedef long fd_mask;
+ *
+ * typedef struct fd_set {
+ * fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+ * } fd_set;
+ *
+ */
+typedef fd_mask cma__t_mask;
+typedef fd_set cma__t_file_mask;
+
+
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * Maximum number of files (ie, max_fd+1) as determined by getdtablesize().
+ */
+extern int cma__g_mx_file;
+
+/*
+ * Number of submasks (ie "int" sized chunks) per file descriptor mask as
+ * determined by getdtablesize().
+ */
+extern int cma__g_nspm;
+
+/*
+ * MACROS
+ */
+
+/*
+ * Define a constant for the errno value which indicates that the requested
+ * operation was not performed because it would block the process.
+ */
+# define cma__is_blocking(s) \
+ ((s == EAGAIN) || (s == EWOULDBLOCK) || (s == EINPROGRESS) || \
+ (s == EALREADY) || (s == EDEADLK))
+
+/*
+* It is necessary to issue an I/O function, before calling cma__io_wait()
+* in the following cases:
+*
+* * This file descriptor has been set non-blocking by CMA
+* * This file descriptor has been set non-blocking by the user.
+*/
+
+#define cma__issue_io_call(fd) \
+ ( (cma__g_file[fd]->non_blocking) || \
+ (cma__g_file[fd]->user_fl.user_non_blocking) )
+
+
+#define cma__set_user_nonblocking(flags) \
+
+/*
+ * Determine if the file is open
+ */
+/*
+ * If the file gets closed while waiting for the mutex cma__g_file[rfd]
+ * gets set to null. This results in a crash if NDEBUG is set to 0
+ * since cma__int_lock tries to dereference it to set the mutex ownership
+ * after it gets the mutex. The following will still set the ownership
+ * in cma__int_lock so we'll set it back to noone if cma__g_file is null
+ * when we come back just in case it matters. It shouldn't since its no
+ * longer in use but.....
+ * Callers of this should recheck cma__g_file after the reservation to
+ * make sure continueing makes sense.
+ */
+#define cma__fd_reserve(rfd) \
+ { \
+ cma__t_int_mutex *__mutex__; \
+ __mutex__ = cma__g_file[rfd]->mutex; \
+ cma__int_lock (__mutex__); \
+ if(cma__g_file[rfd] == (cma__t_file_obj *)cma_c_null_ptr) \
+ cma__int_unlock(__mutex__); \
+ }
+
+
+/*
+ * Unreserve a file descriptor
+ */
+#define cma__fd_unreserve(ufd) cma__int_unlock (cma__g_file[ufd]->mutex)
+
+/*
+ * AND together two select file descriptor masks
+ */
+#define cma__fdm_and(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] & (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Clear a bit in a select file descriptor mask
+ *
+ * FD_CLR(n, p) := ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_clr_bit(n,p) FD_CLR (n, p)
+
+/*
+ * Copy the contents of one file descriptor mask into another. If the
+ * destination operand is null, do nothing; if the source operand is null,
+ * simply zero the destination.
+ */
+#define cma__fdm_copy(src,dst,nfds) { \
+ if (dst) \
+ if (src) { \
+ cma__t_mask *__s__ = (cma__t_mask *)(src); \
+ cma__t_mask *__d__ = (cma__t_mask *)(dst); \
+ int __i__; \
+ for (__i__ = 0; __i__ < (nfds); __i__ += cma__c_nbpm) \
+ *__d__++ = *__s__++; \
+ } \
+ else \
+ cma__fdm_zero (dst); \
+ }
+
+/*
+ * To increment count for each bit set in fd - mask
+ */
+#define cma__fdm_count_bits(map,count) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) { \
+ cma__t_mask __tm__; \
+ __tm__ = (map)->fds_bits[__i__]; \
+ while(__tm__) { \
+ (count)++; \
+ __tm__ &= ~(__tm__ & (-__tm__)); /* Assumes 2's comp */ \
+ } \
+ } \
+ }
+
+/*
+ * Test if a bit is set in a select file descriptor mask
+ *
+ * FD_ISSET(n,p) := ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_is_set(n,p) FD_ISSET (n, p)
+
+/*
+ * OR together two select file descriptor masks
+ */
+#define cma__fdm_or(target,a,b) \
+ { \
+ int __i__ = cma__g_nspm; \
+ while (__i__--) \
+ (target)->fds_bits[__i__] = \
+ (a)->fds_bits[__i__] | (b)->fds_bits[__i__]; \
+ }
+
+/*
+ * Set a bit in a select file descriptor mask
+ *
+ * FD_SET(n,p) := ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_set_bit(n,p) FD_SET (n, p)
+
+/*
+ * Clear a select file descriptor mask.
+ */
+#define cma__fdm_zero(n) \
+ cma__memset ((char *) n, 0, cma__g_nspm * sizeof(cma__t_mask))
+
+
+
+
+
+/*
+ * CMA "thread-synchronous" I/O read/write operations
+ */
+
+ /*
+ * Since all CMA "thread-synchronous" I/O (read or write) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Check that the file descriptor is a legitimate value.
+ * 2. Check that the entry in the CMA file "database" which corresponds to
+ * the file descriptor indicates that the "file" was "opened" by CMA.
+ * 3. Reserve the file, to serialized access to files. This not only
+ * simplifies things, but also defends against non-reentrancy.
+ * 4. If the "file" is "set" for non-blocking I/O, check if we
+ * have actually set the file non-blocking yet, and if not do so.
+ * Then, issue the I/O operantion.
+ * Success or failure is returned immediately, after unreserving the
+ * file. If the error indicates that the operation would have caused
+ * the process to block, continue to the next step.
+ * 5. The I/O prolog adds this "file" to the global bit mask, which
+ * represents all "files" which have threads waiting to perform I/O on
+ * them, and causes the thread to block on the condition variable for
+ * this "file". Periodically, a select is done on this global bit
+ * mask, and the condition variables corresponding to "files" which
+ * are ready for I/O are signaled, releasing those waiting threads to
+ * perform their I/O.
+ * 6. When the thread returns from the I/O prolog, it can (hopefully)
+ * perform its operation without blocking the process.
+ * 7. The I/O epilog clears the bit in the global mask and/or signals the
+ * the next thread waiting for this "file", as appropriate.
+ * 8. If the I/O failed, continue to loop.
+ * 9. Finally, the "file" is unreserved, as we're done with it, and the
+ * result of the operation is returned.
+ *
+ *
+ * Note: currently, we believe that timeslicing which is based on the
+ * virtual-time timer does not cause system calls to return EINTR.
+ * Threfore, any EINTR returns are relayed directly to the caller.
+ * On platforms which do not support a virtual-time timer, the code
+ * should probably catch EINTR returns and restart the system call.
+ */
+
+/*
+ * This macro is used for both read-type and write-type functions.
+ *
+ * Note: the second call to "func" may require being bracketed in a
+ * cma__interrupt_disable/cma__interrupt_enable pair, but we'll
+ * wait and see if this is necessary.
+ */
+#define cma__ts_func(func,fd,arglist,type,post_process) { \
+ cma_t_integer __res__; \
+ cma_t_boolean __done__ = cma_c_false; \
+ if ((fd < 0) || (fd >= cma__g_mx_file)) return (cma__set_errno (EBADF), -1); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ cma__fd_reserve (fd); \
+ if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+ if (cma__issue_io_call(fd)) {\
+ if ((!cma__g_file[fd]->set_non_blocking) && \
+ (cma__g_file[fd]->non_blocking == cma_c_true)) \
+ cma__set_nonblocking(fd); \
+ cma__interrupt_disable (0); \
+ TRY { \
+ __res__ = func arglist; \
+ } \
+ CATCH_ALL { \
+ cma__interrupt_enable (0); \
+ cma__fd_unreserve (fd); \
+ RERAISE; \
+ } \
+ ENDTRY \
+ cma__interrupt_enable (0); \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ if (__done__) { \
+ cma__fd_unreserve (fd); \
+ } \
+ else { \
+ TRY { \
+ cma__io_prolog (type, fd); \
+ while (!__done__) { \
+ cma__io_wait (type, fd); \
+ __res__ = func arglist; \
+ if ((__res__ != -1) \
+ || (!cma__is_blocking (errno)) \
+ || (cma__g_file[fd]->user_fl.user_non_blocking)) \
+ __done__ = cma_c_true; \
+ } \
+ } \
+ FINALLY { \
+ cma__io_epilog (type, fd); \
+ cma__fd_unreserve (fd); \
+ } \
+ ENDTRY \
+ } \
+ if (__res__ != -1) post_process; \
+ return __res__; \
+ }
+
+ /*
+ * Since most CMA "thread-synchronous" I/O ("open"-type) operations on
+ * U*ix follow the exact same structure, the wrapper routines have been
+ * condensed into a macro.
+ *
+ * The steps performed are as follows:
+ * 1. Issue the open function.
+ * 2. If the value returned indicates an error, return it to the caller.
+ * 3. If the file descriptor returned is larger than what we think is the
+ * maximum value (ie if it is too big for our database) then bugcheck.
+ * 4. "Open" the "file" in the CMA file database.
+ * 5. Return the file descriptor value to the caller.
+ *
+ * FIX-ME: for the time being, if the I/O operation returns EINTR, we
+ * simply return it to the caller; eventually, we should catch this
+ * and "do the right thing" (if we can figure out what that is).
+ */
+
+/*
+ * This macro is used for all "open"-type functions which return a single file
+ * desciptor by immediate value.
+ */
+#define cma__ts_open(func,arglist,post_process) { \
+ int __fd__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __fd__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__fd__ >= 0 && __fd__ < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __fd__ = -1; \
+ } \
+ ENDTRY \
+ if (__fd__ >= cma__g_mx_file) \
+ cma__bugcheck ("cma__ts_open: fd is too large"); \
+ return __fd__; \
+ }
+/*
+ * This macro is used for all "open"-type functions which return a pair of file
+ * desciptors by reference parameter.
+ */
+#define cma__ts_open2(func,fdpair,arglist,post_process) { \
+ int __res__; \
+ TRY { \
+ cma__int_init (); \
+ cma__int_lock (cma__g_io_data_mutex); \
+ __res__ = func arglist; \
+ cma__int_unlock (cma__g_io_data_mutex); \
+ if (__res__ >= 0 && fdpair[0] < cma__g_mx_file \
+ && fdpair[1] < cma__g_mx_file) \
+ post_process; \
+ } \
+ CATCH_ALL \
+ { \
+ cma__set_errno (EBADF); \
+ __res__ = -1; \
+ } \
+ ENDTRY \
+ if ((fdpair[0] >= cma__g_mx_file) || (fdpair[1] >= cma__g_mx_file)) \
+ cma__bugcheck ("cma__ts_open2: one of fd's is too large"); \
+ return __res__; \
+ }
+
+/*
+ * INTERNAL INTERFACES
+ */
+extern void cma__close_general (int);
+
+extern void
+cma__init_thread_io (void);
+
+extern cma_t_boolean cma__io_available (cma__t_io_type,int,struct timeval *);
+
+extern void cma__io_epilog (cma__t_io_type,int);
+
+extern void cma__io_prolog (cma__t_io_type,int);
+
+extern void cma__io_wait (cma__t_io_type,int);
+
+extern void cma__open_general (int);
+
+extern void cma__reinit_thread_io (int);
+
+extern void cma__set_nonblocking (int);
+
+extern void cma__set_user_nonblock_flags (int,int);
+
+extern cma_t_boolean
+cma__is_open (int fd);
+
+
+#endif
+
+
RIOS/cma_thread_io.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: cma_sequence.h
===================================================================
--- cma_sequence.h (nonexistent)
+++ cma_sequence.h (revision 513)
@@ -0,0 +1,56 @@
+/*
+ * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.
+ * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY
+ * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION
+ * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
+ * To anyone who acknowledges that this file is provided "AS IS" without
+ * any express or implied warranty: permission to use, copy, modify, and
+ * distribute this file for any purpose is hereby granted without fee,
+ * provided that the above copyright notices and this notice appears in
+ * all source code copies, and that none of the names listed above be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. None of these organizations
+ * makes any representations about the suitability of this software for
+ * any purpose.
+ */
+/*
+ * Header file for sequence generator functions
+ */
+
+#ifndef CMA_SEQUENCE
+#define CMA_SEQUENCE
+
+/*
+ * INCLUDE FILES
+ */
+
+/*
+ * CONSTANTS AND MACROS
+ */
+
+/*
+ * TYPEDEFS
+ */
+
+#ifndef __STDC__
+struct CMA__T_INT_MUTEX;
+#endif
+
+typedef struct CMA__T_SEQUENCE {
+ struct CMA__T_INT_MUTEX *mutex; /* Serialize access to counter */
+ cma_t_natural seq; /* Sequence number for object */
+ } cma__t_sequence;
+
+/*
+ * GLOBAL DATA
+ */
+
+/*
+ * INTERNAL INTERFACES
+ */
+
+extern cma_t_natural cma__assign_sequence (cma__t_sequence *);
+
+extern void cma__init_sequence (cma__t_sequence *);
+
+#endif
cma_sequence.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property