Event marshalling patch for 32/64/endian support.

git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@1131 fd59a12c-fef9-0310-b244-a6a79926bd2f

exec/evt.c

@@ -264,6 +264,76 @@ __attribute__ ((constructor)) static void evt_comp_register (void) {
 	lcr_component_register (&evt_comp_ver0);
 }
 
+/*
+ * MESSAGE_REQ_EXEC_EVT_CHANCMD
+ *
+ * Used for various event related operations.
+ *
+ */
+enum evt_chan_ops {
+	EVT_OPEN_CHAN_OP,		/* chc_chan */
+	EVT_CLOSE_CHAN_OP,  		/* chc_close_unlink_chan */
+	EVT_UNLINK_CHAN_OP,  		/* chc_close_unlink_chan */
+	EVT_CLEAR_RET_OP,		/* chc_event_id */
+	EVT_SET_ID_OP,			/* chc_set_id */
+	EVT_CONF_DONE,			/* no data used */
+	EVT_OPEN_COUNT,			/* chc_set_opens */
+	EVT_OPEN_COUNT_DONE		/* no data used */
+};
+	
+/*
+ * Used during recovery to set the next issued event ID
+ * based on the highest ID seen by any of the members
+ */
+struct evt_set_id {
+	mar_uint32_t 		chc_nodeid __attribute__((aligned(8)));
+	mar_uint64_t		chc_last_id __attribute__((aligned(8)));
+};
+
+/*
+ * For set open count used during recovery to syncronize all nodes
+ *
+ * 	chc_chan_name:		Channel name.
+ * 	chc_open_count:		number of local opens of this channel.
+ */
+struct evt_set_opens {
+	mar_name_t		chc_chan_name __attribute__((aligned(8)));
+	mar_uint32_t		chc_open_count __attribute__((aligned(8)));
+};
+
+/*
+ * Used to communicate channel to close or unlink.
+ */
+#define EVT_CHAN_ACTIVE 0
+struct evt_close_unlink_chan {
+	mar_name_t		chcu_name __attribute__((aligned(8)));
+	mar_uint64_t		chcu_unlink_id __attribute__((aligned(8)));
+};
+
+struct open_chan_req {
+	mar_name_t		ocr_name __attribute__((aligned(8)));
+	mar_uint64_t		ocr_serial_no __attribute__((aligned(8)));
+};
+
+/*
+ * Sent via MESSAGE_REQ_EXEC_EVT_CHANCMD
+ *
+ * chc_head:	Request head
+ * chc_op:		Channel operation (open, close, clear retentiontime)
+ * u:			union of operation options.
+ */
+struct req_evt_chan_command {
+	mar_req_header_t 	chc_head __attribute__((aligned(8)));
+	mar_uint32_t		chc_op __attribute__((aligned(8)));
+	union {
+		struct open_chan_req		chc_chan __attribute__((aligned(8)));
+		mar_evteventid_t		chc_event_id __attribute__((aligned(8)));
+		struct evt_set_id		chc_set_id __attribute__((aligned(8)));
+		struct evt_set_opens 		chc_set_opens __attribute__((aligned(8)));
+		struct evt_close_unlink_chan	chcu __attribute__((aligned(8)));
+	} u;
+};
+
 /* 
  * list of all retained events 
  * 		struct event_data
@@ -344,9 +414,9 @@ enum recovery_phases {
  */
 
 #define BASE_ID_MASK 0xffffffffLL
-static SaEvtEventIdT 	base_id = 1;
-static SaEvtEventIdT 	base_id_top = 0;
-static SaClmNodeIdT  	my_node_id = 0;
+static mar_evteventid_t 	base_id = 1;
+static mar_evteventid_t 	base_id_top = 0;
+static mar_uint32_t  	my_node_id = 0;
 static int 			 	checked_in = 0;
 static int			 	recovery_node = 0;
 static struct list_head *next_retained = 0;
@@ -377,10 +447,10 @@ static int				processed_open_counts = 0;
  */
 struct open_chan_pending {
 	int					ocp_async;
-	SaInvocationT		ocp_invocation;
-	SaNameT				ocp_chan_name;
+	mar_invocation_t	ocp_invocation;
+	mar_name_t			ocp_chan_name;
 	void 				*ocp_conn;
-	SaEvtChannelOpenFlagsT	ocp_open_flag;
+	mar_evtchannelopenflags_t	ocp_open_flag;
 	timer_handle		ocp_timer_handle;
 	uint64_t			ocp_c_handle;
 	uint64_t			ocp_serial_no;
@@ -425,7 +495,7 @@ static DECLARE_LIST_INIT(unlink_pending);
  * rtc_entry:			list entry for pending clear list.
  */
 struct retention_time_clear_pending {
-	SaEvtEventIdT		rtc_event_id;
+	mar_evteventid_t		rtc_event_id;
 	void				*rtc_conn;
 	struct list_head	rtc_entry;
 };
@@ -471,7 +541,7 @@ char lost_evt[] = SA_EVT_LOST_EVENT;
 static int dropped_event_size;
 static struct event_data *dropped_event;
 struct evt_pattern {
-	SaEvtEventPatternT	pat;
+	mar_evt_event_pattern_t	pat;
 	char 	str[sizeof(lost_evt)];
 };
 static struct evt_pattern dropped_pattern = {
@@ -482,12 +552,12 @@ static struct evt_pattern dropped_pattern = {
 		.str = {SA_EVT_LOST_EVENT}
 };
 
-SaNameT lost_chan = {
+mar_name_t lost_chan = {
 	.value = LOST_CHAN,
 	.length = sizeof(LOST_CHAN)
 };
 
-SaNameT dropped_publisher = {
+mar_name_t dropped_publisher = {
 	.value = LOST_PUB,
 	.length = sizeof(LOST_PUB)
 };
@@ -496,7 +566,7 @@ struct event_svr_channel_open;
 struct event_svr_channel_subscr;
 
 struct open_count {
-	SaClmNodeIdT	oc_node_id;
+	mar_uint32_t	oc_node_id;
 	int32_t			oc_open_count;
 };
 
@@ -519,7 +589,7 @@ struct open_count {
  * 						so they get delivered to the proper recipients.
  */
 struct event_svr_channel_instance {
-	SaNameT				esc_channel_name;
+	mar_name_t				esc_channel_name;
 	int32_t				esc_total_opens;
 	int32_t				esc_local_opens;
 	uint32_t			esc_oc_size;
@@ -611,7 +681,7 @@ struct event_svr_channel_open {
 struct event_svr_channel_subscr {
 	struct event_svr_channel_open	*ecs_open_chan;
 	uint32_t						ecs_sub_id;
-	SaEvtEventFilterArrayT			*ecs_filters;
+	mar_evt_event_filter_array_t			*ecs_filters;
 	struct list_head 				ecs_entry;
 };
 
@@ -628,45 +698,45 @@ struct event_svr_channel_subscr {
 struct member_node_data {
 	unsigned int		mn_nodeid;
 	SaClmClusterNodeT	mn_node_info;
-	SaEvtEventIdT		mn_last_msg_id;
-	SaClmNodeIdT		mn_started;
+	mar_evteventid_t		mn_last_msg_id;
+	mar_uint32_t		mn_started;
 	struct member_node_data	*mn_next;
 	struct list_head	mn_entry;
 };
 DECLARE_LIST_INIT(mnd);
 /*
  * Take the filters we received from the application via the library and 
- * make them into a real SaEvtEventFilterArrayT
+ * make them into a real mar_evt_event_filter_array_t
  */
 static SaAisErrorT evtfilt_to_aisfilt(struct req_evt_event_subscribe *req,
-		SaEvtEventFilterArrayT **evtfilters)
+		mar_evt_event_filter_array_t **evtfilters)
 {
 
-	SaEvtEventFilterArrayT *filta = 
-			(SaEvtEventFilterArrayT *)req->ics_filter_data;
-	SaEvtEventFilterArrayT *filters;
-	SaEvtEventFilterT *filt = (void *)filta + sizeof(SaEvtEventFilterArrayT);
-	SaUint8T *str = (void *)filta + sizeof(SaEvtEventFilterArrayT) + 
-			(sizeof(SaEvtEventFilterT) * filta->filtersNumber);
+	mar_evt_event_filter_array_t *filta = 
+			(mar_evt_event_filter_array_t *)req->ics_filter_data;
+	mar_evt_event_filter_array_t *filters;
+	mar_evt_event_filter_t *filt = (void *)filta + sizeof(mar_evt_event_filter_array_t);
+	SaUint8T *str = (void *)filta + sizeof(mar_evt_event_filter_array_t) + 
+			(sizeof(mar_evt_event_filter_t) * filta->filters_number);
 	int i;
 	int j;
 
-	filters = malloc(sizeof(SaEvtEventFilterArrayT));
+	filters = malloc(sizeof(mar_evt_event_filter_array_t));
 	if (!filters) {
 		return SA_AIS_ERR_NO_MEMORY;
 	}
 
-	filters->filtersNumber = filta->filtersNumber;
-	filters->filters = malloc(sizeof(SaEvtEventFilterT) * 
-				filta->filtersNumber);
+	filters->filters_number = filta->filters_number;
+	filters->filters = malloc(sizeof(mar_evt_event_filter_t) * 
+				filta->filters_number);
 	if (!filters->filters) {
 			free(filters);
 			return SA_AIS_ERR_NO_MEMORY;
 	}
 
-	for (i = 0; i < filters->filtersNumber; i++) {
+	for (i = 0; i < filters->filters_number; i++) {
 		filters->filters[i].filter.pattern = 
-			malloc(filt[i].filter.patternSize);
+			malloc(filt[i].filter.pattern_size);
 
 		if (!filters->filters[i].filter.pattern) {
 				for (j = 0; j < i; j++) {
@@ -676,14 +746,14 @@ static SaAisErrorT evtfilt_to_aisfilt(struct req_evt_event_subscribe *req,
 				free(filters);
 				return SA_AIS_ERR_NO_MEMORY;
 		}
-		filters->filters[i].filter.patternSize = 
-			filt[i].filter.patternSize;
-		filters->filters[i].filter.allocatedSize = 
-			filt[i].filter.patternSize;
+		filters->filters[i].filter.pattern_size = 
+			filt[i].filter.pattern_size;
+		filters->filters[i].filter.allocated_size = 
+			filt[i].filter.pattern_size;
 		memcpy(filters->filters[i].filter.pattern,
-				str, filters->filters[i].filter.patternSize);
-		filters->filters[i].filterType = filt[i].filterType;
-		str += filters->filters[i].filter.patternSize;
+				str, filters->filters[i].filter.pattern_size);
+		filters->filters[i].filter_type = filt[i].filter_type;
+		str += filters->filters[i].filter.pattern_size;
 	}
 
 	*evtfilters = filters;
@@ -694,11 +764,11 @@ static SaAisErrorT evtfilt_to_aisfilt(struct req_evt_event_subscribe *req,
 /*
  * Free up filter data
  */
-static void free_filters(SaEvtEventFilterArrayT *fp)
+static void free_filters(mar_evt_event_filter_array_t *fp)
 {
 	int i;
 
-	for (i = 0; i < fp->filtersNumber; i++) {
+	for (i = 0; i < fp->filters_number; i++) {
 		free(fp->filters[i].filter.pattern);
 	}
 
@@ -710,7 +780,7 @@ static void free_filters(SaEvtEventFilterArrayT *fp)
  * Look up a channel in the global channel list
  */
 static struct event_svr_channel_instance *
-find_channel(SaNameT *chan_name, uint64_t unlink_id)
+find_channel(mar_name_t *chan_name, uint64_t unlink_id)
 {
 	struct list_head *l, *head;
 	struct event_svr_channel_instance *eci;
@@ -727,7 +797,7 @@ find_channel(SaNameT *chan_name, uint64_t unlink_id)
 	for (l = head->next; l != head; l = l->next) {
 
 		eci = list_entry(l, struct event_svr_channel_instance, esc_entry);
-		if (!name_match(chan_name, &eci->esc_channel_name)) {
+		if (!mar_name_match(chan_name, &eci->esc_channel_name)) {
 			continue;
 		} else if (unlink_id != eci->esc_unlink_id) {
 			continue;
@@ -741,7 +811,7 @@ find_channel(SaNameT *chan_name, uint64_t unlink_id)
  * Find the last unlinked version of a channel.
  */
 static struct event_svr_channel_instance *
-find_last_unlinked_channel(SaNameT *chan_name)
+find_last_unlinked_channel(mar_name_t *chan_name)
 {
 	struct list_head *l;
 	struct event_svr_channel_instance *eci;
@@ -753,7 +823,7 @@ find_last_unlinked_channel(SaNameT *chan_name)
 	for (l = esc_unlinked_head.next; l != &esc_unlinked_head; l = l->next) {
 
 		eci = list_entry(l, struct event_svr_channel_instance, esc_entry);
-		if (!name_match(chan_name, &eci->esc_channel_name)) {
+		if (!mar_name_match(chan_name, &eci->esc_channel_name)) {
 			continue;
 		} 
 	}
@@ -763,7 +833,7 @@ find_last_unlinked_channel(SaNameT *chan_name)
 /*
  * Create and initialize a channel instance structure
  */
-static struct event_svr_channel_instance *create_channel(SaNameT *cn)
+static struct event_svr_channel_instance *create_channel(mar_name_t *cn)
 {
 	struct event_svr_channel_instance *eci;
 	eci = (struct event_svr_channel_instance *) malloc(sizeof(*eci));
@@ -819,7 +889,7 @@ static int check_open_size(struct event_svr_channel_instance *eci)
  */
 static struct open_count* find_open_count(
 		struct event_svr_channel_instance *eci,
-		SaClmNodeIdT node_id)
+		mar_uint32_t node_id)
 {
 	int i;
 
@@ -897,7 +967,7 @@ static void zero_chan_open_counts()
  * Replace the current open count for a node with the specified value.
  */
 static int set_open_count(struct event_svr_channel_instance *eci,
-		SaClmNodeIdT node_id, uint32_t open_count) 
+		mar_uint32_t node_id, uint32_t open_count) 
 {
 	struct open_count *oc;
 	int i;
@@ -925,7 +995,7 @@ static int set_open_count(struct event_svr_channel_instance *eci,
  * Increment the open count for the specified node.
  */
 static int inc_open_count(struct event_svr_channel_instance *eci,
-		SaClmNodeIdT node_id) 
+		mar_uint32_t node_id) 
 {
 
 	struct open_count *oc;
@@ -952,7 +1022,7 @@ static int inc_open_count(struct event_svr_channel_instance *eci,
  * specified channel.
  */
 static int dec_open_count(struct event_svr_channel_instance *eci,
-		SaClmNodeIdT node_id) 
+		mar_uint32_t node_id) 
 {
 
 	struct open_count *oc;
@@ -1101,7 +1171,7 @@ static void unlink_channel(struct event_svr_channel_instance *eci,
  */
 static int remove_open_count(
 		struct event_svr_channel_instance *eci,
-		SaClmNodeIdT node_id)
+		mar_uint32_t node_id)
 {
 	int i;
 	int j;
@@ -1147,7 +1217,7 @@ static int remove_open_count(
 /*
  * Send a request to open a channel to the rest of the cluster.
  */
-static SaAisErrorT evt_open_channel(SaNameT *cn, SaUint8T flgs)
+static SaAisErrorT evt_open_channel(mar_name_t *cn, SaUint8T flgs)
 {
 	struct req_evt_chan_command cpkt;
 	struct event_svr_channel_instance *eci;
@@ -1199,7 +1269,7 @@ chan_open_end:
 /*
  * Send a request to close a channel with the rest of the cluster.
  */
-static SaAisErrorT evt_close_channel(SaNameT *cn, uint64_t unlink_id)
+static SaAisErrorT evt_close_channel(mar_name_t *cn, uint64_t unlink_id)
 {
 	struct req_evt_chan_command cpkt;
 	struct iovec chn_iovec;
@@ -1400,13 +1470,13 @@ static int check_last_event(
  * upper 32 bits of the event ID to make sure that we can generate a cluster
  * wide unique event ID for a given event.
  */
-SaAisErrorT set_event_id(SaClmNodeIdT node_id)
+SaAisErrorT set_event_id(mar_uint32_t node_id)
 {
 	SaAisErrorT err = SA_AIS_OK;
 	if (base_id_top) {
 		err =  SA_AIS_ERR_EXIST;
 	}
-	base_id_top = (SaEvtEventIdT)node_id << 32;
+	base_id_top = (mar_evteventid_t)node_id << 32;
 	return err;
 }
 
@@ -1418,7 +1488,7 @@ static int id_in_use(uint64_t id, uint64_t base)
 {
 	struct list_head *l;
 	struct event_data *edp;
-	SaEvtEventIdT evtid = (id << 32) | (base & BASE_ID_MASK);
+	mar_evteventid_t evtid = (id << 32) | (base & BASE_ID_MASK);
 	
 	for (l = retained_list.next; l != &retained_list; l = l->next) {
 		edp = list_entry(l, struct event_data, ed_retained);
@@ -1484,7 +1554,7 @@ event_retention_timeout(void *data)
  *
  */
 static SaAisErrorT
-clear_retention_time(SaEvtEventIdT event_id)
+clear_retention_time(mar_evteventid_t event_id)
 {
 	struct event_data *edp;
 	struct list_head *l, *nxt;
@@ -1604,38 +1674,38 @@ evt_already_delivered(struct event_data *evt,
  * return SA_AIS_OK if the pattern matches a filter
  */
 static SaAisErrorT
-filter_match(SaEvtEventPatternT *ep, SaEvtEventFilterT *ef)
+filter_match(mar_evt_event_pattern_t *ep, mar_evt_event_filter_t *ef)
 {
 	int ret;
 	ret = SA_AIS_ERR_FAILED_OPERATION;
 
-	switch (ef->filterType) {
+	switch (ef->filter_type) {
 	case SA_EVT_PREFIX_FILTER:
-		if (ef->filter.patternSize > ep->patternSize) {
+		if (ef->filter.pattern_size > ep->pattern_size) {
 			break;
 		}
 		if (strncmp((char *)ef->filter.pattern, (char *)ep->pattern,
-					ef->filter.patternSize) == 0) {
+					ef->filter.pattern_size) == 0) {
 			ret = SA_AIS_OK;
 		}
 		break;
 	case SA_EVT_SUFFIX_FILTER:
-		if (ef->filter.patternSize > ep->patternSize) {
+		if (ef->filter.pattern_size > ep->pattern_size) {
 			break;
 		}
 		if (strncmp((char *)ef->filter.pattern, 
-			(char *)&ep->pattern[ep->patternSize - ef->filter.patternSize],
-					ef->filter.patternSize) == 0) {
+			(char *)&ep->pattern[ep->pattern_size - ef->filter.pattern_size],
+					ef->filter.pattern_size) == 0) {
 			ret = SA_AIS_OK;
 		}
 		
 		break;
 	case SA_EVT_EXACT_FILTER:
-		if (ef->filter.patternSize != ep->patternSize) {
+		if (ef->filter.pattern_size != ep->pattern_size) {
 			break;
 		}
 		if (strncmp((char *)ef->filter.pattern, (char *)ep->pattern,
-					ef->filter.patternSize) == 0) {
+					ef->filter.pattern_size) == 0) {
 			ret = SA_AIS_OK;
 		}
 		break;
@@ -1656,15 +1726,15 @@ static SaAisErrorT
 event_match(struct event_data *evt, 
 			struct event_svr_channel_subscr *ecs)
 {
-	SaEvtEventFilterT *ef;
-	SaEvtEventPatternT *ep;
+	mar_evt_event_filter_t *ef;
+	mar_evt_event_pattern_t *ep;
 	uint32_t filt_count;
 	SaAisErrorT ret =  SA_AIS_OK;
 	int i;
 
-	ep = (SaEvtEventPatternT *)(&evt->ed_event.led_body[0]);
+	ep = (mar_evt_event_pattern_t *)(&evt->ed_event.led_body[0]);
 	ef = ecs->ecs_filters->filters;
-	filt_count = min(ecs->ecs_filters->filtersNumber, 
+	filt_count = min(ecs->ecs_filters->filters_number, 
 			evt->ed_event.led_patterns_number);
 
 	for (i = 0; i < filt_count; i++) {
@@ -1931,7 +2001,7 @@ static void
 convert_event(void *msg)
 {
 	struct lib_event_data *evt = (struct lib_event_data *)msg;
-	SaEvtEventPatternT *eps;
+	mar_evt_event_pattern_t *eps;
 	int i;
 
 	/*
@@ -1963,10 +2033,10 @@ convert_event(void *msg)
 	 * We can't do anything about user data since it doesn't have a specified
 	 * format.  The application is on its own here.
 	 */
-	eps = (SaEvtEventPatternT *)evt->led_body;  
+	eps = (mar_evt_event_pattern_t *)evt->led_body;  
 	for (i = 0; i < evt->led_patterns_number; i++) {
-		eps->patternSize = swab32(eps->patternSize);
-		eps->allocatedSize = swab32(eps->allocatedSize);
+		eps->pattern_size = swab32(eps->pattern_size);
+		eps->allocated_size = swab32(eps->allocated_size);
 		eps++;
 	}
 	
@@ -1982,7 +2052,7 @@ make_local_event(struct lib_event_data *p,
 			struct event_svr_channel_instance *eci)
 {
 	struct event_data *ed;
-	SaEvtEventPatternT *eps;
+	mar_evt_event_pattern_t *eps;
 	SaUint8T *str;
 	uint32_t ed_size;
 	int i;
@@ -2005,12 +2075,12 @@ make_local_event(struct lib_event_data *p,
 	memcpy(&ed->ed_event, p, sizeof(*p) + 
 					p->led_user_data_offset + p->led_user_data_size);
 
-	eps = (SaEvtEventPatternT *)ed->ed_event.led_body;  
+	eps = (mar_evt_event_pattern_t *)ed->ed_event.led_body;  
 	str = ed->ed_event.led_body + 
-			(ed->ed_event.led_patterns_number * sizeof(SaEvtEventPatternT));
+			(ed->ed_event.led_patterns_number * sizeof(mar_evt_event_pattern_t));
 	for (i = 0; i < ed->ed_event.led_patterns_number; i++) {
 		eps->pattern = str;
-		str += eps->patternSize;
+		str += eps->pattern_size;
 		eps++;
 	}
 
@@ -2448,7 +2518,7 @@ static void lib_evt_event_subscribe(void *conn, void *message)
 {
 	struct req_evt_event_subscribe *req;
 	struct res_evt_event_subscribe res;
-	SaEvtEventFilterArrayT *filters;
+	mar_evt_event_filter_array_t *filters;
 	SaAisErrorT error;
 	struct event_svr_channel_open	*eco;
 	struct event_svr_channel_instance *eci;
@@ -2495,13 +2565,13 @@ static void lib_evt_event_subscribe(void *conn, void *message)
 
 	if (error == SA_AIS_OK) {
 		log_printf(LOG_LEVEL_DEBUG, "Subscribe filters count %d\n", 
-				filters->filtersNumber);
-		for (i = 0; i < filters->filtersNumber; i++) {
+				filters->filters_number);
+		for (i = 0; i < filters->filters_number; i++) {
 			log_printf(LOG_LEVEL_DEBUG, "type %s(%d) sz %d, <%s>\n", 
-					filter_types[filters->filters[i].filterType],
-					filters->filters[i].filterType,
-					filters->filters[i].filter.patternSize,
-					(filters->filters[i].filter.patternSize) 
+					filter_types[filters->filters[i].filter_type],
+					filters->filters[i].filter_type,
+					filters->filters[i].filter.pattern_size,
+					(filters->filters[i].filter.pattern_size) 
 						? (char *)filters->filters[i].filter.pattern
 						: "");
 		}
@@ -2613,7 +2683,7 @@ static void lib_evt_event_unsubscribe(void *conn, void *message)
 			"unsubscribe from channel %s subscription ID 0x%x "
 			"with %d filters\n", 
 			eci->esc_channel_name.value,
-			ecs->ecs_sub_id, ecs->ecs_filters->filtersNumber);
+			ecs->ecs_sub_id, ecs->ecs_filters->filters_number);
 
 	free_filters(ecs->ecs_filters);
 	free(ecs);
@@ -2636,7 +2706,7 @@ static void lib_evt_event_publish(void *conn, void *message)
 	struct res_evt_event_publish res;
 	struct event_svr_channel_open	*eco;
 	struct event_svr_channel_instance *eci;
-	SaEvtEventIdT event_id = 0;
+	mar_evteventid_t event_id = 0;
 	uint64_t msg_id = 0;
 	SaAisErrorT error = SA_AIS_OK;
 	struct iovec pub_iovec;
@@ -2824,7 +2894,7 @@ data_get_done:
 /*
  * Scan the list of channels and remove the specified node.
  */
-static void remove_chan_open_info(SaClmNodeIdT node_id)
+static void remove_chan_open_info(mar_uint32_t node_id)
 {
 	struct list_head *l, *nxt;
 	struct event_svr_channel_instance *eci;
@@ -3228,8 +3298,8 @@ static void evt_remote_evt(void *msg, unsigned int nodeid)
 /*
  * Calculate the remaining retention time of a received event during recovery
  */
-inline SaTimeT calc_retention_time(SaTimeT retention, 
-								SaTimeT received, SaTimeT now)
+inline mar_time_t calc_retention_time(mar_time_t retention, 
+								mar_time_t received, mar_time_t now)
 {
 	if ((received < now) && ((now - received) < retention)) {
 		return retention - (now - received);
@@ -3255,7 +3325,7 @@ static void evt_remote_recovery_evt(void *msg, unsigned int nodeid)
 	struct event_data *evt;
 	struct member_node_data *md;
 	int num_delivered;
-	SaTimeT now;
+	mar_time_t now;
 
 	now = clust_time_now();
 
@@ -3379,7 +3449,7 @@ static void evt_chan_open_finish(struct open_chan_pending *ocp,
 	esip = (struct libevt_pd *)openais_conn_private_data_get(ocp->ocp_conn);
 
 	log_printf(CHAN_OPEN_DEBUG, "Open channel finish %s\n",
-											getSaNameT(&ocp->ocp_chan_name));
+											get_mar_name_t(&ocp->ocp_chan_name));
 	if (ocp->ocp_timer_handle) {
 		openais_timer_delete (ocp->ocp_timer_handle);
 	}
@@ -3390,12 +3460,12 @@ static void evt_chan_open_finish(struct open_chan_pending *ocp,
 	 */
 	if (ocp->ocp_invocation == OPEN_TIMED_OUT) {
 		log_printf(CHAN_OPEN_DEBUG, "Closing timed out open of %s\n",
-				getSaNameT(&ocp->ocp_chan_name));
+				get_mar_name_t(&ocp->ocp_chan_name));
 		error = evt_close_channel(&ocp->ocp_chan_name, EVT_CHAN_ACTIVE);
 		if (error != SA_AIS_OK) {
 			log_printf(CHAN_OPEN_DEBUG,
 					"Close of timed out open failed for %s\n",
-					getSaNameT(&ocp->ocp_chan_name));
+					get_mar_name_t(&ocp->ocp_chan_name));
 		}
 		list_del(&ocp->ocp_entry);
 		free(ocp);
@@ -3438,7 +3508,7 @@ static void evt_chan_open_finish(struct open_chan_pending *ocp,
 
 open_return:
 	log_printf(CHAN_OPEN_DEBUG, "Open channel finish %s send response %d\n", 
-											getSaNameT(&ocp->ocp_chan_name),
+											get_mar_name_t(&ocp->ocp_chan_name),
 											error);
 	if (ocp->ocp_async) {
 		struct res_evt_open_chan_async resa;
@@ -3631,7 +3701,7 @@ static void evt_remote_chan_op(void *msg, unsigned int nodeid)
 		}
 		if (!eci) {
 			log_printf(LOG_LEVEL_WARNING, "Could not create channel %s\n",
-				   getSaNameT(&cpkt->u.chc_chan.ocr_name));
+				   get_mar_name_t(&cpkt->u.chc_chan.ocr_name));
 			break;
 		}
 
@@ -3656,7 +3726,7 @@ static void evt_remote_chan_op(void *msg, unsigned int nodeid)
 		}
 		log_printf(CHAN_OPEN_DEBUG, 
 				"Open channel %s t %d, l %d, r %d\n",
-				getSaNameT(&eci->esc_channel_name),
+				get_mar_name_t(&eci->esc_channel_name),
 				eci->esc_total_opens, eci->esc_local_opens,
 				eci->esc_retained_count);
 		break;
@@ -3839,11 +3909,11 @@ static void evt_remote_chan_op(void *msg, unsigned int nodeid)
 		}
 		if (!eci) {
 			log_printf(LOG_LEVEL_WARNING, "Could not create channel %s\n",
-				   getSaNameT(&cpkt->u.chc_set_opens.chc_chan_name));
+				   get_mar_name_t(&cpkt->u.chc_set_opens.chc_chan_name));
 			break;
 		}
 		if (set_open_count(eci, mn->mn_node_info.nodeId, 
-									cpkt->u.chc_set_opens.chc_open_count)) {
+			cpkt->u.chc_set_opens.chc_open_count)) {
 			log_printf(LOG_LEVEL_ERROR, 
 				"Error setting Open channel count %s for node %s\n",
 				cpkt->u.chc_set_opens.chc_chan_name.value, 

include/ipc_evt.h

@@ -39,6 +39,7 @@
 #include "saEvt.h"
 #include "saClm.h"
 #include "ipc_gen.h"
+#include "mar_evt.h"
 
 enum req_evt_types {
 	MESSAGE_REQ_EVT_OPEN_CHANNEL = 0,
@@ -69,22 +70,21 @@ enum res_evt_types {
  * MESSAGE_REQ_EVT_OPEN_CHANNEL
  * MESSAGE_REQ_EVT_OPEN_CHANNEL_ASYNC
  *
- * ico_head				Request head
- * ico_open_flag:		Channel open flags
+ * ico_head		Request head
+ * ico_open_flag:	Channel open flags
  * ico_channel_name:	Name of channel to open
- * ico_c_handle:		Local lib channel handle (used in returned event data)
- * ico_timeout:			Used only by open
- * ico_invocation:		Used only by async open
+ * ico_c_handle:	Local lib channel handle (used in returned event data)
+ * ico_timeout:		Used only by open
+ * ico_invocation:	Used only by async open
  *
  */
 struct req_evt_channel_open {
-
-	mar_req_header_t		ico_head;
-	SaUint8T				ico_open_flag;
-	SaNameT					ico_channel_name;
-	SaEvtChannelHandleT		ico_c_handle;
-	SaTimeT					ico_timeout;
-	SaInvocationT			ico_invocation;
+	mar_req_header_t	ico_head __attribute__((aligned(8)));
+	mar_uint8_t		ico_open_flag __attribute__((aligned(8)));
+	mar_name_t		ico_channel_name __attribute__((aligned(8)));
+	mar_evtchannelhandle_t	ico_c_handle __attribute__((aligned(8)));
+	mar_time_t		ico_timeout __attribute__((aligned(8)));
+	mar_invocation_t	ico_invocation __attribute__((aligned(8)));
 };
 
 /*
@@ -98,13 +98,13 @@ struct req_evt_channel_open {
  *
  * ico_head:			Results head
  * ico_error:			Request results
- * ico_channel_handle:	Server side channel handle (used in channel ops)
+ * ico_channel_handle:		Server side channel handle (used in channel ops)
  *
  */
 struct res_evt_channel_open {
 
-	mar_res_header_t	ico_head;
-	uint32_t			ico_channel_handle;/* svr chan handle */
+	mar_res_header_t	ico_head __attribute__((aligned(8)));
+	mar_uint32_t		ico_channel_handle __attribute__((aligned(8)));/* svr chan handle */
 
 };
 
@@ -120,10 +120,10 @@ struct res_evt_channel_open {
  * 						to the particular open.
  */
 struct res_evt_open_chan_async {
-	mar_res_header_t	ica_head;
-	SaEvtChannelHandleT	ica_c_handle;
-	uint32_t			ica_channel_handle;
-	SaInvocationT		ica_invocation;
+	mar_res_header_t	ica_head __attribute__((aligned(8)));
+	mar_evtchannelhandle_t	ica_c_handle __attribute__((aligned(8)));
+	mar_uint32_t		ica_channel_handle __attribute__((aligned(8)));
+	mar_invocation_t	ica_invocation __attribute__((aligned(8)));
 
 };
 
@@ -132,13 +132,12 @@ struct res_evt_open_chan_async {
  * MESSAGE_REQ_EVT_CLOSE_CHANNEL
  *
  * icc_head:			Request head
- * icc_channel_handle:	Server handle of channel to close
+ * icc_channel_handle:		Server handle of channel to close
  *
  */
 struct req_evt_channel_close {
-
-	mar_req_header_t		icc_head;
-	uint32_t				icc_channel_handle;
+	mar_req_header_t	icc_head __attribute__((aligned(8)));
+	mar_uint32_t		icc_channel_handle __attribute__((aligned(8)));
 };
 
 /*
@@ -148,7 +147,7 @@ struct req_evt_channel_close {
  *
  */
 struct res_evt_channel_close {
-	mar_res_header_t	icc_head;
+	mar_res_header_t	icc_head __attribute__((aligned(8)));
 };
 
 /*
@@ -159,9 +158,8 @@ struct res_evt_channel_close {
  *
  */
 struct req_evt_channel_unlink {
-
-	mar_req_header_t		iuc_head;
-	SaNameT					iuc_channel_name;
+	mar_req_header_t	iuc_head __attribute__((aligned(8)));
+	mar_name_t		iuc_channel_name __attribute__((aligned(8)));
 };
 
 /*
@@ -171,28 +169,27 @@ struct req_evt_channel_unlink {
  *
  */
 struct res_evt_channel_unlink {
-	mar_res_header_t	iuc_head;
+	mar_res_header_t	iuc_head __attribute__((aligned(8)));
 };
 
 /* 
  * MESSAGE_REQ_EVT_SUBSCRIBE
  *
  * ics_head:			Request head
- * ics_channel_handle:	Server handle of channel
+ * ics_channel_handle:		Server handle of channel
  * ics_sub_id:			Subscription ID
  * ics_filter_size:		Size of supplied filter data
- * ics_filter_count:	Number of filters supplied
+ * ics_filter_count:		Number of filters supplied
  * ics_filter_data:		Filter data
  *
  */
 struct req_evt_event_subscribe {
-
-	mar_req_header_t		ics_head;
-	uint32_t				ics_channel_handle;
-	SaEvtSubscriptionIdT	ics_sub_id;
-	uint32_t				ics_filter_size;
-	uint32_t				ics_filter_count;
-	uint8_t					ics_filter_data[0];
+	mar_req_header_t	ics_head __attribute__((aligned(8)));
+	mar_uint32_t		ics_channel_handle __attribute__((aligned(8)));
+	mar_evtsubscriptionid_t	ics_sub_id __attribute__((aligned(8)));
+	mar_uint32_t		ics_filter_size __attribute__((aligned(8)));
+	mar_uint32_t		ics_filter_count __attribute__((aligned(8)));
+	mar_uint8_t		ics_filter_data[0] __attribute__((aligned(8)));
 
 };
 
@@ -204,7 +201,7 @@ struct req_evt_event_subscribe {
  *
  */
 struct res_evt_event_subscribe {
-	mar_res_header_t	ics_head;
+	mar_res_header_t	ics_head __attribute__((aligned(8)));
 };
 
 /*
@@ -216,10 +213,9 @@ struct res_evt_event_subscribe {
  *
  */
 struct req_evt_event_unsubscribe {
-
-	mar_req_header_t		icu_head;
-	uint32_t				icu_channel_handle;
-	SaEvtSubscriptionIdT	icu_sub_id;
+	mar_req_header_t	icu_head __attribute__((aligned(8)));
+	mar_uint32_t		icu_channel_handle __attribute__((aligned(8)));
+	mar_evtsubscriptionid_t icu_sub_id __attribute__((aligned(8)));
 };
 
 
@@ -231,7 +227,7 @@ struct req_evt_event_unsubscribe {
  *
  */
 struct res_evt_event_unsubscribe {
-	mar_res_header_t	icu_head;
+	mar_res_header_t	icu_head __attribute__((aligned(8)));
 
 };
 
@@ -242,55 +238,55 @@ struct res_evt_event_unsubscribe {
  * evd_head:		Request Head
  */
 struct res_evt_event_data {
-		mar_res_header_t	evd_head;
+	mar_res_header_t	evd_head __attribute__((aligned(8)));
 };
 
 /*
  * MESSAGE_REQ_EVT_PUBLISH			(1)
- * MESSAGE_RES_EVT_EVENT_DATA		(2)
- * MESSAGE_REQ_EXEC_EVT_EVENTDATA	(3)
+ * MESSAGE_RES_EVT_EVENT_DATA			(2)
+ * MESSAGE_REQ_EXEC_EVT_EVENTDATA		(3)
  * MESSAGE_REQ_EXEC_EVT_RECOVERY_EVENTDATA	(4)
  *
- * led_head:				Request/Results head
- * led_addr:				address of node (4 only)
+ * led_head:			Request/Results head
+ * led_addr:			address of node (4 only)
  * led_receive_time:		Time that the message was received (4 only)
  * led_svr_channel_handle:	Server channel handle (1 only)
  * led_lib_channel_handle:	Lib channel handle (2 only)
- * led_chan_name:			Channel name (3 and 4 only)
+ * led_chan_name:		Channel name (3 and 4 only)
  * led_chan_unlink_id:		directs delivery to unlinked channels.
- * led_event_id:			Event ID (2, 3 and 4 only)
- * led_msg_id:				message ID (2, 3 and 4 only)
- * led_sub_id:				Subscription ID (2 only)
+ * led_event_id:		Event ID (2, 3 and 4 only)
+ * led_msg_id:			message ID (2, 3 and 4 only)
+ * led_sub_id:			Subscription ID (2 only)
  * led_publisher_node_id:	Node ID of event publisher
  * led_publisher_name:		Node name of event publisher
  * led_retention_time:		Event retention time
  * led_publish_time:		Publication time of the event
- * led_priority:			Event priority
+ * led_priority:		Event priority
  * led_user_data_offset:	Offset to user data
  * led_user_data_size:		Size of user data
  * led_patterns_number:		Number of patterns in the event
- * led_body:				Pattern and user data
+ * led_body:			Pattern and user data
  */
 struct lib_event_data {
-	mar_res_header_t		led_head;
-	unsigned int			led_nodeid;
-	SaTimeT					led_receive_time;
-	uint32_t				led_svr_channel_handle;
-	SaEvtChannelHandleT		led_lib_channel_handle;
-	SaNameT					led_chan_name;
-	uint64_t				led_chan_unlink_id;
-	SaEvtEventIdT			led_event_id;
-	uint64_t				led_msg_id;
-	SaEvtSubscriptionIdT	led_sub_id;
-	SaClmNodeIdT			led_publisher_node_id;
-	SaNameT					led_publisher_name;
-	SaTimeT					led_retention_time;
-	SaTimeT					led_publish_time;
-	SaEvtEventPriorityT		led_priority;
-	uint32_t				led_user_data_offset;
-	uint32_t				led_user_data_size;
-	uint32_t				led_patterns_number;
-	uint8_t					led_body[0];
+	mar_res_header_t	led_head __attribute__((aligned(8)));
+	mar_uint32_t		led_nodeid __attribute__((aligned(8)));
+	mar_time_t		led_receive_time __attribute__((aligned(8)));
+	mar_uint32_t		led_svr_channel_handle __attribute__((aligned(8)));
+	mar_evtchannelhandle_t	led_lib_channel_handle __attribute__((aligned(8)));
+	mar_name_t		led_chan_name __attribute__((aligned(8)));
+	mar_uint64_t		led_chan_unlink_id __attribute__((aligned(8)));
+	mar_evteventid_t	led_event_id __attribute__((aligned(8)));
+	mar_uint64_t		led_msg_id __attribute__((aligned(8)));
+	mar_evtsubscriptionid_t	led_sub_id __attribute__((aligned(8)));
+	mar_uint32_t		led_publisher_node_id __attribute__((aligned(8)));
+	mar_name_t		led_publisher_name __attribute__((aligned(8)));
+	mar_time_t		led_retention_time __attribute__((aligned(8)));
+	mar_time_t		led_publish_time __attribute__((aligned(8)));
+	mar_evteventpriority_t	led_priority __attribute__((aligned(8)));
+	mar_uint32_t		led_user_data_offset __attribute__((aligned(8)));
+	mar_uint32_t		led_user_data_size __attribute__((aligned(8)));
+	mar_uint32_t		led_patterns_number __attribute__((aligned(8)));
+	mar_uint8_t		led_body[0] __attribute__((aligned(8)));
 };
 
 /*
@@ -302,9 +298,8 @@ struct lib_event_data {
  *
  */
 struct res_evt_event_publish {
-
-	mar_res_header_t	iep_head;
-	SaEvtEventIdT		iep_event_id;
+	mar_res_header_t	iep_head __attribute__((aligned(8)));
+	mar_evteventid_t	iep_event_id __attribute__((aligned(8)));
 };
 
 /*
@@ -319,9 +314,9 @@ struct res_evt_event_publish {
  */
 struct req_evt_event_clear_retentiontime {
 
-	mar_req_header_t	iec_head;
-	SaEvtEventIdT		iec_event_id;
-	uint32_t			iec_channel_handle;
+	mar_req_header_t	iec_head __attribute__((aligned(8)));
+	mar_evteventid_t	iec_event_id __attribute__((aligned(8)));
+	mar_uint32_t		iec_channel_handle __attribute__((aligned(8)));
 
 };
 
@@ -333,81 +328,7 @@ struct req_evt_event_clear_retentiontime {
  *
  */
 struct res_evt_event_clear_retentiontime {
-	mar_res_header_t	iec_head;
-};
-
-
-/*
- * MESSAGE_REQ_EXEC_EVT_CHANCMD
- *
- * Used for various event related operations.
- *
- */
-enum evt_chan_ops {
-	EVT_OPEN_CHAN_OP,		/* chc_chan */
-	EVT_CLOSE_CHAN_OP,  	/* chc_close_unlink_chan */
-	EVT_UNLINK_CHAN_OP,  	/* chc_close_unlink_chan */
-	EVT_CLEAR_RET_OP,		/* chc_event_id */
-	EVT_SET_ID_OP,			/* chc_set_id */
-	EVT_CONF_DONE,			/* no data used */
-	EVT_OPEN_COUNT,			/* chc_set_opens */
-	EVT_OPEN_COUNT_DONE		/* no data used */
-};
-	
-/*
- * Used during recovery to set the next issued event ID
- * based on the highest ID seen by any of the members
- */
-struct evt_set_id {
-	unsigned int 	chc_nodeid;
-	uint64_t		chc_last_id;
-};
-
-/*
- * For set open count used during recovery to syncronize all nodes
- *
- * 	chc_chan_name:		Channel name.
- * 	chc_open_count:		number of local opens of this channel.
- */
-struct evt_set_opens {
-	SaNameT		chc_chan_name;
-	uint32_t	chc_open_count;
-};
-
-/*
- * Used to communicate channel to close or unlink.
- */
-#define EVT_CHAN_ACTIVE 0
-struct evt_close_unlink_chan {
-	SaNameT		chcu_name;
-	uint64_t	chcu_unlink_id;
-};
-
-struct open_chan_req {
-	SaNameT		ocr_name;
-	uint64_t	ocr_serial_no;
-};
-
-/*
- * Sent via MESSAGE_REQ_EXEC_EVT_CHANCMD
- *
- * chc_head:	Request head
- * chc_op:		Channel operation (open, close, clear retentiontime)
- * u:			union of operation options.
- */
-struct req_evt_chan_command {
-	mar_req_header_t 	chc_head;
-	int 				chc_op;
-	union {
-		struct open_chan_req	chc_chan;
-		SaEvtEventIdT			chc_event_id;
-		struct evt_set_id		chc_set_id;
-		struct evt_set_opens 	chc_set_opens;
-		struct evt_close_unlink_chan	chcu;
-	} u;
+	mar_res_header_t	iec_head __attribute__((aligned(8)));
 };
 
 #endif  /* AIS_EVT_H_DEFINED */
-/*
- *	vi: set autoindent tabstop=4 shiftwidth=4 :
- */

include/mar_evt.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2004-2005 Mark Haverkamp
+ * Copyright (c) 2004-2005 Open Source Development Lab
+ *
+ * All rights reserved.
+ *
+ * This software licensed under BSD license, the text of which follows:
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the Open Source Developement Lab nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef MAR_EVT_H_DEFINED
+#define MAR_EVT_H_DEFINED
+
+#include "mar_gen.h"
+
+typedef mar_uint64_t mar_evtchannelhandle_t;
+
+typedef mar_uint64_t mar_evtsubscriptionid_t;
+
+typedef mar_uint8_t mar_evteventpriority_t;
+
+typedef mar_uint64_t mar_evteventid_t;
+
+typedef mar_uint8_t mar_evtchannelopenflags_t;
+
+typedef struct {
+	mar_size_t allocated_size __attribute__((aligned(8)));
+	mar_size_t pattern_size __attribute__((aligned(8)));
+	mar_uint8_t *pattern __attribute__((aligned(8)));
+} mar_evt_event_pattern_t;
+
+
+typedef struct {
+	mar_size_t allocated_number __attribute__((aligned(8)));
+	mar_size_t patterns_number __attribute__((aligned(8)));
+	mar_evt_event_pattern_t *patterns __attribute__((aligned(8)));
+} mar_evt_event_pattern_array_t;
+
+typedef enum {
+	MAR_EVT_PREFIX_FILTER = 1,
+	MAR_EVT_SUFFIX_FILTER = 2,
+	MAR_EVT_EXACT_FILTER = 3,
+	MAR_EVT_PASS_ALL_FILTER = 4
+} mar_evt_event_filter_type_t;
+
+typedef struct {
+	mar_evt_event_filter_type_t filter_type __attribute__((aligned(8)));
+	mar_evt_event_pattern_t filter __attribute__((aligned(8)));
+} mar_evt_event_filter_t;
+
+typedef struct {
+	mar_size_t filters_number __attribute__((aligned(8)));
+	mar_evt_event_filter_t *filters __attribute__((aligned(8)));
+} mar_evt_event_filter_array_t;
+
+#endif /* MAR_EVT_H_DEFINED */

include/saEvt.h

@@ -57,8 +57,8 @@ typedef void
 );
 
 typedef struct{
-    SaEvtChannelOpenCallbackT saEvtChannelOpenCallback;
-    SaEvtEventDeliverCallbackT saEvtEventDeliverCallback; 
+	SaEvtChannelOpenCallbackT saEvtChannelOpenCallback;
+	SaEvtEventDeliverCallbackT saEvtEventDeliverCallback; 
 } SaEvtCallbacksT;
 
 #define SA_EVT_CHANNEL_PUBLISHER  0X1
@@ -68,8 +68,8 @@ typedef SaUint8T SaEvtChannelOpenFlagsT;
 
 typedef struct {
 	SaSizeT	allocatedSize;
-    SaSizeT patternSize;
-    SaUint8T *pattern;
+	SaSizeT patternSize;
+	SaUint8T *pattern;
 } SaEvtEventPatternT;
 
 
@@ -103,28 +103,28 @@ typedef struct {
 
 typedef struct {
 	SaSizeT allocatedNumber;
-    SaSizeT patternsNumber;
-    SaEvtEventPatternT *patterns;
+	SaSizeT patternsNumber;
+	SaEvtEventPatternT *patterns;
 } SaEvtEventPatternArrayT;
 
 typedef SaUint8T SaEvtEventPriorityT;
 typedef SaUint64T SaEvtEventIdT;
 
 typedef enum {
-    SA_EVT_PREFIX_FILTER = 1,
-    SA_EVT_SUFFIX_FILTER = 2,
-    SA_EVT_EXACT_FILTER = 3,
-    SA_EVT_PASS_ALL_FILTER = 4
+	SA_EVT_PREFIX_FILTER = 1,
+	SA_EVT_SUFFIX_FILTER = 2,
+	SA_EVT_EXACT_FILTER = 3,
+	SA_EVT_PASS_ALL_FILTER = 4
 } SaEvtEventFilterTypeT;
 
 typedef struct {
-    SaEvtEventFilterTypeT filterType;
-    SaEvtEventPatternT filter;
+	SaEvtEventFilterTypeT filterType;
+	SaEvtEventPatternT filter;
 } SaEvtEventFilterT;
 
 typedef struct {
-    SaSizeT filtersNumber;
-    SaEvtEventFilterT *filters;
+	SaSizeT filtersNumber;
+	SaEvtEventFilterT *filters;
 } SaEvtEventFilterArrayT;
 
 
@@ -236,6 +236,3 @@ saEvtEventRetentionTimeClear(
 }
 #endif
 #endif /* AIS_EVT_H_DEFINED */
-/*
- *	vi: set autoindent tabstop=4 shiftwidth=4 :
- */

lib/evt.c

@@ -457,7 +457,7 @@ static SaAisErrorT make_event(SaEvtEventHandleT *event_handle,
 {
 	struct event_data_instance *edi;
 	struct event_channel_instance *eci;
-	SaEvtEventPatternT *pat;
+	mar_evt_event_pattern_t *pat;
 	SaUint8T *str;
 	SaAisErrorT error;
 	struct handle_list *hl;
@@ -497,7 +497,8 @@ static SaAisErrorT make_event(SaEvtEventHandleT *event_handle,
 	edi->edi_pub_time = evt->led_publish_time;
 	edi->edi_event_data_size = evt->led_user_data_size;
 	edi->edi_event_id = evt->led_event_id;
-	edi->edi_pub_name = evt->led_publisher_name;
+	marshall_from_mar_name_t (&edi->edi_pub_name, &evt->led_publisher_name);
+
 	if (edi->edi_event_data_size) {
 		edi->edi_event_data = malloc(edi->edi_event_data_size);
 		if (!edi->edi_event_data) {
@@ -537,23 +538,24 @@ static SaAisErrorT make_event(SaEvtEventHandleT *event_handle,
 	}
 	memset(edi->edi_patterns.patterns, 0, sizeof(SaEvtEventPatternT) *
 					edi->edi_patterns.patternsNumber);
-	pat = (SaEvtEventPatternT *)evt->led_body;
-	str = evt->led_body + sizeof(SaEvtEventPatternT) * 
+	pat = (mar_evt_event_pattern_t *)evt->led_body;
+	str = evt->led_body + sizeof(mar_evt_event_pattern_t) * 
 						edi->edi_patterns.patternsNumber;
 	for (i = 0; i < evt->led_patterns_number; i++) {
-		edi->edi_patterns.patterns[i].patternSize = pat->patternSize;
-		edi->edi_patterns.patterns[i].allocatedSize = pat->patternSize;
-		edi->edi_patterns.patterns[i].pattern = malloc(pat->patternSize);
+		edi->edi_patterns.patterns[i].patternSize = pat->pattern_size;
+		edi->edi_patterns.patterns[i].allocatedSize = pat->pattern_size;
+		edi->edi_patterns.patterns[i].pattern = malloc(pat->pattern_size);
 		if (!edi->edi_patterns.patterns[i].pattern) {
             DPRINT (("make_event: couldn't alloc %llu bytes\n",
-				(unsigned long long)pat->patternSize));
+				(unsigned long long)pat->pattern_size));
 			saHandleDestroy(&event_handle_db, *event_handle);
 			error =  SA_AIS_ERR_LIBRARY;
 			goto make_evt_done_put2;
 		}
+		// TODO marshall pattern
 		memcpy(edi->edi_patterns.patterns[i].pattern,
-				str, pat->patternSize);
-		str += pat->patternSize;
+				str, pat->pattern_size);
+		str += pat->pattern_size;
 		pat++; 
 	}
 
@@ -984,8 +986,7 @@ saEvtChannelOpen(
 	req.ico_c_handle = *channelHandle;
 	req.ico_timeout = timeout;
 	req.ico_open_flag = channelOpenFlags;
-	req.ico_channel_name = *channelName;
-
+	marshall_to_mar_name_t (&req.ico_channel_name, (SaNameT *)channelName);
 
 	iov.iov_base = &req;
 	iov.iov_len = sizeof(req);
@@ -1211,7 +1212,7 @@ saEvtChannelOpenAsync(SaEvtHandleT evtHandle,
 	req.ico_timeout = 0;
 	req.ico_invocation = invocation;
 	req.ico_open_flag = channelOpenFlags;
-	req.ico_channel_name = *channelName;
+	marshall_to_mar_name_t (&req.ico_channel_name, (SaNameT *)channelName);
 	iov.iov_base = &req;
 	iov.iov_len = sizeof(req);
 
@@ -1312,7 +1313,7 @@ saEvtChannelUnlink(
 	 */
 	req.iuc_head.size = sizeof(req);
 	req.iuc_head.id = MESSAGE_REQ_EVT_UNLINK_CHANNEL;
-	req.iuc_channel_name = *channelName;
+	marshall_to_mar_name_t (&req.iuc_channel_name, (SaNameT *)channelName);
 	iov.iov_base = &req;
 	iov.iov_len = sizeof(req);
 
@@ -1785,9 +1786,9 @@ data_get_done:
 static size_t patt_size(const SaEvtEventPatternArrayT *patterns)
 {
 	int i;
-	size_t size = sizeof(SaEvtEventPatternArrayT);
+	size_t size = sizeof(mar_evt_event_pattern_array_t);
 	for (i = 0; i < patterns->patternsNumber; i++) {
-		size += sizeof(SaEvtEventPatternT);
+		size += sizeof(mar_evt_event_pattern_t);
 		size += patterns->patterns[i].patternSize;
 	}
 	return size;
@@ -1796,11 +1797,12 @@ static size_t patt_size(const SaEvtEventPatternArrayT *patterns)
 /*
  * copy patterns to a form for sending to the server
  */
-static uint32_t aispatt_to_evt_patt(const SaEvtEventPatternArrayT *patterns, 
+static uint32_t aispatt_to_evt_patt(
+	const SaEvtEventPatternArrayT *patterns, 
 		void *data)
 {
 	int i;
-	SaEvtEventPatternT *pats = data;
+	mar_evt_event_pattern_t *pats = data;
 	SaUint8T *str  = (SaUint8T *)pats + 
 				(patterns->patternsNumber * sizeof(*pats));
 
@@ -1809,9 +1811,10 @@ static uint32_t aispatt_to_evt_patt(const SaEvtEventPatternArrayT *patterns,
 	 * will be later converted back into pointers when received as events.
 	 */
 	for (i = 0; i < patterns->patternsNumber; i++) {
+	// TODO marshall?
 		memcpy(str, patterns->patterns[i].pattern, 
 			 	patterns->patterns[i].patternSize);
-		pats->patternSize = patterns->patterns[i].patternSize;
+		pats->pattern_size = patterns->patterns[i].patternSize;
 		pats->pattern = (SaUint8T *)((void *)str - data);
 		str += patterns->patterns[i].patternSize;
 		pats++;
@@ -1825,10 +1828,10 @@ static uint32_t aispatt_to_evt_patt(const SaEvtEventPatternArrayT *patterns,
 static size_t filt_size(const SaEvtEventFilterArrayT *filters)
 {
 	int i;
-	size_t size = sizeof(SaEvtEventFilterArrayT);
+	size_t size = sizeof(mar_evt_event_filter_array_t);
 
 	for (i = 0; i < filters->filtersNumber; i++) {
-		size += sizeof(SaEvtEventFilterT);
+		size += sizeof(mar_evt_event_filter_t);
 		size += filters->filters[i].filter.patternSize;
 	}
 	return size;
@@ -1839,12 +1842,13 @@ static size_t filt_size(const SaEvtEventFilterArrayT *filters)
  * i.e. replace pointers with offsets.  The pointers will be reconstituted
  * by the receiver.
  */
-static uint32_t aisfilt_to_evt_filt(const SaEvtEventFilterArrayT *filters, 
-		void *data)
+static uint32_t aisfilt_to_evt_filt(
+	const SaEvtEventFilterArrayT *filters, 
+	void *data)
 {
 	int i;
-	SaEvtEventFilterArrayT *filta = data;
-	SaEvtEventFilterT *filts = data + sizeof(SaEvtEventFilterArrayT);
+	mar_evt_event_filter_array_t *filtd = data;
+	mar_evt_event_filter_t *filts = data + sizeof(mar_evt_event_filter_array_t);
 	SaUint8T *str = (SaUint8T *)filts +
 			(filters->filtersNumber * sizeof(*filts));
 
@@ -1852,13 +1856,14 @@ static uint32_t aisfilt_to_evt_filt(const SaEvtEventFilterArrayT *filters,
 	 * Pointers are replaced with offsets into the data array.  These
 	 * will be later converted back into pointers by the evt server.
 	 */
-	filta->filters = (SaEvtEventFilterT *)((void *)filts - data);
-	filta->filtersNumber = filters->filtersNumber;
+	filtd->filters = (mar_evt_event_filter_t *)((void *)filts - data);
+	filtd->filters_number = filters->filtersNumber;
 
 	for (i = 0; i < filters->filtersNumber; i++) {
-		filts->filterType = filters->filters[i].filterType;
-		filts->filter.patternSize = 
+		filts->filter_type = filters->filters[i].filterType;
+		filts->filter.pattern_size = 
 			filters->filters[i].filter.patternSize;
+			// TODO marshall pattern
 		memcpy(str,
 			 filters->filters[i].filter.pattern, 
 			 filters->filters[i].filter.patternSize);
@@ -1985,7 +1990,7 @@ saEvtEventPublish(
 	req->led_retention_time = edi->edi_retention_time;
 	req->led_publish_time = clustTimeNow();
 	req->led_priority = edi->edi_priority;
-	req->led_publisher_name = edi->edi_pub_name;
+	marshall_to_mar_name_t (&req->led_publisher_name, &edi->edi_pub_name);
 
 	iov.iov_base = req;
 	iov.iov_len = req->led_head.size;
@@ -2068,7 +2073,7 @@ saEvtEventSubscribe(
 
 	/*
 	 * Make sure that a deliver callback has been 
-	 * registered before  allowing the subscribe to continue.
+	 * registered before allowing the subscribe to continue.
 	 */
 	if (!evti->ei_callback.saEvtEventDeliverCallback) {
 		error = SA_AIS_ERR_INIT;
@@ -2099,7 +2104,7 @@ saEvtEventSubscribe(
 	 * Copy the supplied filters to the request
 	 */
 	req->ics_filter_count = aisfilt_to_evt_filt(filters, 
-						req->ics_filter_data);
+		req->ics_filter_data);
 	req->ics_head.id = MESSAGE_REQ_EVT_SUBSCRIBE;
 	req->ics_head.size = sizeof(*req) + sz;
 	req->ics_channel_handle = eci->eci_svr_channel_handle;