Remove priorities from all interfaces.

(Logical change 1.121)


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

exec/amf.c

@@ -75,16 +75,6 @@ struct invocation *invocation_entries = 0;
 
 int invocation_entries_size = 0;
 
-static DECLARE_LIST_INIT (mcast_list);
-
-struct mcast_data {
-	struct list_head	mlist;
-	char 			mcast[MCAST_DATA_NUM][MCAST_DATA_LEN];
-	struct iovec 		iovec[MCAST_DATA_NUM];
-	int			iovec_num;
-	int			priority;
-};
-
 //TODO static void *tok_call_handle = NULL;
 
 static int recovery = 0;
@@ -160,14 +150,6 @@ static int activeServiceUnitsCount (
 static void component_unregister (
 	struct saAmfComponent *component);
 
-static void component_register_priority (
-	struct saAmfComponent *component,
-	int priority);
-
-static void component_unregister_priority (
-	struct saAmfComponent *component,
-	int priority);
-
 static void enumerate_components (
 	void (*function)(struct saAmfComponent *, void *data),
 	void *data);
@@ -274,10 +256,6 @@ static int amf_exec_init_fn (void);
 
 static void amf_synchronize (void *message, struct in_addr source_addr);
 
-static void amf_mcast (struct iovec *iovec, int iov_len, int priority);
-
-static int amf_mcast_retain ();
-
 static int message_handler_req_exec_amf_componentregister (void *message, struct in_addr source_addr, int endian_conversion_required);
 
 static int message_handler_req_exec_amf_componentunregister (void *message, struct in_addr source_addr, int endian_conversion_required);
@@ -339,73 +317,61 @@ struct libais_handler amf_libais_handlers[] =
 		.libais_handler_fn	= message_handler_req_lib_activatepoll,
 		.response_size		= sizeof (struct res_lib_activatepoll),
 		.response_id		= MESSAGE_RES_LIB_ACTIVATEPOLL, // TODO RESPONSE
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 1 */
 		.libais_handler_fn	= message_handler_req_amf_componentregister,
 		.response_size		= sizeof (struct res_lib_amf_componentregister),
 		.response_id		= MESSAGE_RES_AMF_COMPONENTREGISTER,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 2 */
 		.libais_handler_fn	= message_handler_req_amf_componentunregister,
 		.response_size		= sizeof (struct res_lib_amf_componentunregister),
 		.response_id		= MESSAGE_RES_AMF_COMPONENTUNREGISTER,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 3 */
 		.libais_handler_fn	= message_handler_req_amf_readinessstateget,
 		.response_size		= sizeof (struct res_lib_amf_readinessstateget),
 		.response_id		= MESSAGE_RES_AMF_READINESSSTATEGET,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 4 */
 		.libais_handler_fn	= message_handler_req_amf_hastateget,
 		.response_size		= sizeof (struct res_lib_amf_hastateget),
 		.response_id		= MESSAGE_RES_AMF_READINESSSTATEGET,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 5 */
 		.libais_handler_fn	= message_handler_req_amf_protectiongrouptrackstart,
 		.response_size		= sizeof (struct res_lib_amf_protectiongrouptrackstart),
 		.response_id		= MESSAGE_RES_AMF_PROTECTIONGROUPTRACKSTART,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 6 */
 		.libais_handler_fn	= message_handler_req_amf_protectiongrouptrackstop,
 		.response_size		= sizeof (struct res_lib_amf_protectiongrouptrackstop),
 		.response_id		= MESSAGE_RES_AMF_PROTECTIONGROUPTRACKSTOP,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 7 */
 		.libais_handler_fn	= message_handler_req_amf_errorreport,
 		.response_size		= sizeof (struct res_lib_amf_errorreport),
 		.response_id		= MESSAGE_RES_AMF_ERRORREPORT,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 8 */
 		.libais_handler_fn	= message_handler_req_amf_errorcancelall,
 		.response_size		= sizeof (struct res_lib_amf_errorcancelall),
 		.response_id		= MESSAGE_RES_AMF_ERRORCANCELALL,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 9 */
 		.libais_handler_fn	= message_handler_req_amf_stoppingcomplete,
 		.response_size		= sizeof (struct res_lib_amf_stoppingcomplete),
 		.response_id		= MESSAGE_RES_AMF_STOPPINGCOMPLETE, // TODO 
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 10 */
 		.libais_handler_fn	= message_handler_req_amf_response,
 		.response_size		= sizeof (struct res_lib_amf_response),
 		.response_id		= MESSAGE_RES_AMF_RESPONSE, // TODO
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 11 */
 		.libais_handler_fn	= message_handler_req_amf_componentcapabilitymodelget,
 		.response_size		= sizeof (struct res_lib_amf_componentcapabilitymodelget),
 		.response_id		= MESSAGE_RES_AMF_COMPONENTCAPABILITYMODELGET,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	}
 };
 
@@ -508,9 +474,8 @@ int req_amf_invocation_get_and_destroy (int invocation, int *interface,
 	return (0);
 }
 
-static void component_unregister_priority (
-	struct saAmfComponent *component,
-	int priority)
+static void component_unregister (
+	struct saAmfComponent *component)
 {
 	struct req_exec_amf_componentunregister req_exec_amf_componentunregister;
 	struct iovec iovecs[2];
@@ -540,19 +505,11 @@ static void component_unregister_priority (
 	iovecs[0].iov_base = (char *)&req_exec_amf_componentunregister;
 	iovecs[0].iov_len = sizeof (req_exec_amf_componentunregister);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, priority) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 }
 
-static void component_unregister (
+static void component_register (
 	struct saAmfComponent *component)
-{
-	component_unregister_priority (component, TOTEMPG_PRIO_MED);
-	return;
-}
-
-static void component_register_priority (
-	struct saAmfComponent *component,
-	int priority)
 {
 	struct req_exec_amf_componentregister req_exec_amf_componentregister;
 	struct iovec iovecs[2];
@@ -584,8 +541,6 @@ static void component_register_priority (
 
 	iovecs[0].iov_base = (char *)&req_exec_amf_componentregister;
 	iovecs[0].iov_len = sizeof (req_exec_amf_componentregister);
-
-	amf_mcast (iovecs, 1, priority);
 }
 
 /***
@@ -767,36 +722,12 @@ void ha_state_api_set (struct saAmfComponent *component, SaAmfHAStateT haState)
 		sizeof (struct res_lib_amf_csisetcallback));
 }
 
-#ifdef COMPILE_OUT
-
-void haStateSetClusterInit (
-	struct conn_info *conn_info,
-	struct saAmfComponent *saAmfComponent)
-{
-	struct req_exec_amf_hastatesetcluster req_exec_amf_hastatesetcluster;
-
-	return;
-	req_exec_amf_hastatesetcluster.header.id = MESSAGE_REQ_EXEC_AMF_HASTATESET;
-	req_exec_amf_hastatesetcluster.header.size = sizeof (struct req_exec_amf_hastatesetcluster);
-	memcpy (&req_exec_amf_hastatesetcluster.compName,
-		&saAmfComponent->name, sizeof (SaNameT));
-	req_exec_amf_hastatesetcluster.haState = saAmfComponent->currentHAState;
-
-	log_printf (LOG_LEVEL_DEBUG, "Sending init ha state message to cluster node to set ha state of component %s\n", getSaNameT (&saAmfComponent->name));
-	log_printf (LOG_LEVEL_DEBUG, "ha state is %d\n", saAmfComponent->currentHAState);
-
-	libais_send_response (conn_info, &req_exec_amf_hastatesetcluster,
-		sizeof (struct req_exec_amf_hastatesetcluster));
-}
-#endif
-
 static void ha_state_group_set (
 	struct saAmfComponent *component,
 	SaAmfHAStateT haState)
 {
 	struct req_exec_amf_hastateset req_exec_amf_hastateset;
 	struct iovec iovecs[2];
-	int priority;
 
 	req_exec_amf_hastateset.header.id = MESSAGE_REQ_EXEC_AMF_HASTATESET;
 	req_exec_amf_hastateset.header.size = sizeof (struct req_exec_amf_hastateset);
@@ -809,13 +740,7 @@ static void ha_state_group_set (
 	iovecs[0].iov_base = (char *)&req_exec_amf_hastateset;
 	iovecs[0].iov_len = sizeof (req_exec_amf_hastateset);
 
-	if (recovery == 1) {
-		priority = TOTEMPG_PRIO_RECOVERY;
-	} else {
-		priority = TOTEMPG_PRIO_HIGH;
-	}
-
-	amf_mcast (iovecs, 1, priority);
+	totempg_mcast (iovecs, 1, TOTEMPG_AGREED);
 }
 
 void readiness_state_api_set (struct saAmfComponent *component,
@@ -864,36 +789,12 @@ void readiness_state_api_set (struct saAmfComponent *component,
 		sizeof (struct res_lib_amf_readinessstatesetcallback));
 }
 
-#ifdef COMPILE_OUT
-void readinessStateSetClusterInit (
-	struct conn_info *conn_info,
-	struct saAmfComponent *saAmfComponent)
-{
-
-	struct req_exec_amf_readinessstatesetcluster req_exec_amf_readinessstatesetcluster;
-
-	return;
-	req_exec_amf_readinessstatesetcluster.header.id = MESSAGE_REQ_EXEC_AMF_READINESSSTATESET;
-	req_exec_amf_readinessstatesetcluster.header.size = sizeof (struct req_exec_amf_readinessstateset);
-	memcpy (&req_exec_amf_readinessstatesetcluster.compName,
-		&saAmfComponent->name, sizeof (SaNameT));
-	req_exec_amf_readinessstatesetcluster.readinessState = saAmfComponent->currentReadinessState;
-
-	log_printf (LOG_LEVEL_DEBUG, "Sending init message to one cluster node to set readiness state of component %s\n", getSaNameT (&saAmfComponent->name));
-	log_printf (LOG_LEVEL_DEBUG, "readiness state is %d\n", saAmfComponent->currentReadinessState);
-
-	libais_send_response (conn_info, &req_exec_amf_readinessstatesetcluster,
-		sizeof (struct req_exec_amf_readinessstatesetcluster));
-}
-#endif
-
 static void readiness_state_group_set (
 	struct saAmfComponent *component,
 	SaAmfReadinessStateT readinessState)
 {
 	struct req_exec_amf_readinessstateset req_exec_amf_readinessstateset;
 	struct iovec iovecs[2];
-	int priority;
 
 	req_exec_amf_readinessstateset.header.id = MESSAGE_REQ_EXEC_AMF_READINESSSTATESET;
 	req_exec_amf_readinessstateset.header.size = sizeof (struct req_exec_amf_readinessstateset);
@@ -907,28 +808,9 @@ static void readiness_state_group_set (
 	iovecs[0].iov_base = (char *)&req_exec_amf_readinessstateset;
 	iovecs[0].iov_len = sizeof (req_exec_amf_readinessstateset);
 
-	if (recovery == 1) {
-		priority = TOTEMPG_PRIO_RECOVERY;
-	} else {
-		priority = TOTEMPG_PRIO_HIGH;
-	}
-
-	amf_mcast (iovecs, 1, priority);
+	totempg_mcast (iovecs, 1, TOTEMPG_AGREED);
 }
 
-#ifdef CMOPILE_OUT
-void enumerateComponentsClusterInit (
-	struct saAmfComponent *component,
-	void *data)
-{
-	struct conn_info *conn_info = (int)data;
-
-	return;
-	readinessStateSetClusterInit (fd, component);
-	haStateSetClusterInit (fd, component);
-}
-#endif
-
 static void dsmDisabledUnlockedRegisteredOrErrorCancel (
 	struct saAmfComponent *component)
 {
@@ -1545,7 +1427,7 @@ void error_report (
 	iovecs[0].iov_base = (char *)&req_exec_amf_errorreport;
 	iovecs[0].iov_len = sizeof (req_exec_amf_errorreport);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 }
 
 int healthcheck_instance = 0;
@@ -1954,7 +1836,7 @@ void amf_confchg_njoin (struct saAmfComponent *component ,void *data)
 		return;
 	}
 
-	component_register_priority (component, TOTEMPG_PRIO_RECOVERY);
+	component_register (component);
 	return;
 }
 
@@ -2518,7 +2400,7 @@ static int message_handler_req_amf_componentregister (struct conn_info *conn_inf
 	iovecs[0].iov_base = (char *)&req_exec_amf_componentregister;
 	iovecs[0].iov_len = sizeof (req_exec_amf_componentregister);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	return (0);
 }
 
@@ -2547,7 +2429,7 @@ static int message_handler_req_amf_componentunregister (struct conn_info *conn_i
 	iovecs[0].iov_base = (char *)&req_exec_amf_componentunregister;
 	iovecs[0].iov_len = sizeof (req_exec_amf_componentunregister);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	return (0);
 }
 
@@ -2728,7 +2610,7 @@ static int message_handler_req_amf_errorreport (struct conn_info *conn_info, voi
 //	iovecs[1].iov_base = (char *)&req_lib_amf_errorreport;
 //	iovecs[1].iov_len = sizeof (req_lib_amf_errorreport);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 
 	return (0);
 }
@@ -2758,7 +2640,7 @@ static int message_handler_req_amf_errorcancelall (struct conn_info *conn_info,
 //	iovecs[1].iov_base = (char *)&req_lib_amf_errorcancelall;
 //	iovecs[1].iov_len = sizeof (req_lib_amf_errorcancelall);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 
 	return (0);
 }
@@ -2860,97 +2742,6 @@ static int message_handler_req_amf_componentcapabilitymodelget (struct conn_info
 	return (0);
 }
 
-#ifdef COMPILE_OUT
-int totempg_mcast2 (
-	struct totempg_groupname *groupname,
-	struct iovec *iovec,
-	int iov_len,
-	int priority)
-{
-	static int i = 0;
-
-	if (i%2==0) {
-		return (-1);
-	}
-
-	amf_mcast_retain ();
-	totempg_mcast (groupname, iovec, iov_len, TOTEMPG_AGREED, priority);
-}
-#endif
-
-static void amf_mcast (struct iovec *iovec, int iovec_num, int priority)
-{
-	int i;
-	int ret;
-	struct mcast_data *mcast;
-
-	if (mcast_list.next == &mcast_list) {
-		ret = totempg_mcast (iovec, iovec_num, TOTEMPG_AGREED, priority);
-		if (ret == 0) {
-			return;
-		}
-// TODO		assert (totempg_token_callback_create (&tok_call_handle, amf_mcast_retain, NULL) == 0);
-	}
-
-	mcast = (struct mcast_data *) malloc (sizeof(*mcast));
-	assert (mcast != NULL);
-	if (mcast == NULL) {
-		log_printf (LOG_LEVEL_ERROR, "Allocation Error in AMF_MCAST\n");
-		return;
-	}
-
-	mcast->iovec[0].iov_base = (void *)(mcast->mcast[0]);
-	mcast->iovec[1].iov_base = (void *)(mcast->mcast[1]);
-
-	assert (iovec_num <= MCAST_DATA_NUM);
-	for (i=0; i<iovec_num; i++) {
-
-		mcast[i].iovec[i].iov_len = iovec[i].iov_len;
-		assert (iovec[i].iov_len <= MCAST_DATA_LEN);
-		log_printf (LOG_LEVEL_ERROR, "Length over in AMF_MCAST\n");
-		memcpy (mcast[i].iovec[i].iov_base, iovec[i].iov_base, iovec[i].iov_len);
-	}
-
-        mcast->iovec_num = iovec_num;
-        mcast->priority = priority;
-        list_add_tail (&mcast->mlist, &mcast_list);
-
-	return;
-}
-
-static int amf_mcast_retain ()
-{
-	struct list_head *list;
-	struct list_head *list_next;
-	struct mcast_data *mdata;
-	int priority;
-	int ret;
-
-	for (priority = TOTEMPG_PRIO_RECOVERY; priority < TOTEMPG_PRIO_LOW; priority++) {
-	for (list=mcast_list.next; list != &mcast_list; list=list_next) {
-
-		mdata = list_entry (list, struct mcast_data, mlist);
-		list_next = list->next;
-		if (mdata->priority != priority) {
-			continue;
-		}
-
-		list_del (list);
-
-		ret = totempg_mcast (mdata->iovec, mdata->iovec_num, TOTEMPG_AGREED, mdata->priority);
-		if (ret == -1) {
-			list_add (list ,&mcast_list);
-// TODO		assert (totempg_token_callback_create (&tok_call_handle, amf_mcast_retain, NULL) == 0);
-			break;
-		}
-
-		free (mdata);
-	}
-	}
-
-	return (0);
-}
-
 static char disabled_unlocked_state_text[6][64] = {
 	"AMF_DISABLED_UNLOCKED_REGISTEREDORERRORCANCEL",
 	"AMF_DISABLED_UNLOCKED_FAILED",

exec/ckpt.c

@@ -155,7 +155,6 @@ struct libais_handler ckpt_libais_handlers[] =
 		.libais_handler_fn			= message_handler_req_lib_activatepoll,
 		.response_size				= sizeof (struct res_lib_activatepoll),
 		.response_id				= MESSAGE_RES_LIB_ACTIVATEPOLL,
-		.totempg_prio					= TOTEMPG_PRIO_RECOVERY
 	}
 };
 
@@ -186,91 +185,76 @@ struct libais_handler ckpt_checkpoint_libais_handlers[] =
 		.libais_handler_fn	= message_handler_req_lib_activatepoll,
 		.response_size		= sizeof (struct res_lib_activatepoll),
 		.response_id		= MESSAGE_RES_LIB_ACTIVATEPOLL,
-		.totempg_prio		= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 1 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointopen,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointopen),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTOPEN,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 2 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointopenasync,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointopenasync),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTOPENASYNC,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 3 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointunlink,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointunlink),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTUNLINK,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 4 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointretentiondurationset,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointretentiondurationset),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTRETENTIONDURATIONSET,
-		.totempg_prio		= TOTEMPG_PRIO_LOW
 	},
 	{ /* 5 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_activecheckpointset,
 		.response_size		= sizeof (struct res_lib_ckpt_activecheckpointset),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_ACTIVECHECKPOINTSET,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 6 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointstatusget,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointstatusget),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTSTATUSGET,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 7 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectioncreate,
 		.response_size		= sizeof (struct res_lib_ckpt_sectioncreate),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONCREATE,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 8 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectiondelete,
 		.response_size		= sizeof (struct res_lib_ckpt_sectiondelete),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONDELETE,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 9 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectionexpirationtimeset,
 		.response_size		= sizeof (struct res_lib_ckpt_sectionexpirationtimeset),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONEXPIRATIONTIMESET,
-		.totempg_prio		= TOTEMPG_PRIO_LOW
 	},
 	{ /* 10 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectionwrite,
 		.response_size		= sizeof (struct res_lib_ckpt_sectionwrite),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONWRITE,
-		.totempg_prio		= TOTEMPG_PRIO_LOW
 	},
 	{ /* 11 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectionoverwrite,
 		.response_size		= sizeof (struct res_lib_ckpt_sectionoverwrite),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONOVERWRITE,
-		.totempg_prio		= TOTEMPG_PRIO_LOW
 	},
 	{ /* 12 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_sectionread,
 		.response_size		= sizeof (struct res_lib_ckpt_sectionread),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_SECTIONREAD,
-		.totempg_prio		= TOTEMPG_PRIO_LOW
 	},
 	{ /* 13 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointsynchronize,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointsynchronize),
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTSYNCHRONIZE,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 	{ /* 14 */
 		.libais_handler_fn	= message_handler_req_lib_ckpt_checkpointsynchronizeasync,
 		.response_size		= sizeof (struct res_lib_ckpt_checkpointsynchronizeasync), // TODO RESPONSE
 		.response_id		= MESSAGE_RES_CKPT_CHECKPOINT_CHECKPOINTSYNCHRONIZEASYNC,
-		.totempg_prio		= TOTEMPG_PRIO_MED
 	},
 };
 
@@ -307,19 +291,16 @@ struct libais_handler ckpt_sectioniterator_libais_handlers[] =
 		.libais_handler_fn			= message_handler_req_lib_activatepoll,
 		.response_size				= sizeof (struct res_lib_activatepoll),
 		.response_id				= MESSAGE_RES_LIB_ACTIVATEPOLL,
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 1 */
 		.libais_handler_fn			= message_handler_req_lib_ckpt_sectioniteratorinitialize,
 		.response_size				= sizeof (struct res_lib_ckpt_sectioniteratorinitialize),
 		.response_id				= MESSAGE_RES_CKPT_SECTIONITERATOR_SECTIONITERATORINITIALIZE,
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 2 */
 		.libais_handler_fn			= message_handler_req_lib_ckpt_sectioniteratornext,
 		.response_size				= sizeof (struct res_lib_ckpt_sectioniteratornext),
 		.response_id				= MESSAGE_RES_CKPT_SECTIONITERATOR_SECTIONITERATORNEXT,
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	}
 };
 
@@ -437,8 +418,8 @@ int sendCkptCheckpointClose (struct saCkptCheckpoint *checkpoint) {
 	iovecs[0].iov_base = (char *)&req_exec_ckpt_checkpointclose;
 	iovecs[0].iov_len = sizeof (req_exec_ckpt_checkpointclose);
 
-	if (totempg_send_ok (TOTEMPG_PRIO_HIGH, sizeof (struct req_exec_ckpt_checkpointclose))) {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_HIGH) == 0);
+	if (totempg_send_ok (sizeof (struct req_exec_ckpt_checkpointclose))) {
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 		return (0);
 	}
 
@@ -651,7 +632,7 @@ void timer_function_retention (void *data)
 	iovec.iov_base = (char *)&req_exec_ckpt_checkpointretentiondurationexpire;
 	iovec.iov_len = sizeof (req_exec_ckpt_checkpointretentiondurationexpire);
 
-	assert (totempg_mcast (&iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (&iovec, 1, TOTEMPG_AGREED) == 0);
 }
 
 extern int message_handler_req_exec_ckpt_checkpointclose (void *message, struct in_addr source_addr, int endian_conversion_required)
@@ -797,7 +778,7 @@ static int message_handler_req_exec_ckpt_checkpointretentiondurationexpire (void
 		iovecs[0].iov_base = (char *)&req_exec_ckpt_checkpointunlink;
 		iovecs[0].iov_len = sizeof (req_exec_ckpt_checkpointunlink);
 
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 	return (0);
 }
@@ -1356,7 +1337,7 @@ static int message_handler_req_lib_ckpt_checkpointopen (struct conn_info *conn_i
 	iovecs[0].iov_base = (char *)&req_exec_ckpt_checkpointopen;
 	iovecs[0].iov_len = sizeof (req_exec_ckpt_checkpointopen);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 
 	return (0);
 }
@@ -1387,7 +1368,7 @@ static int message_handler_req_lib_ckpt_checkpointunlink (struct conn_info *conn
 	iovecs[0].iov_base = (char *)&req_exec_ckpt_checkpointunlink;
 	iovecs[0].iov_len = sizeof (req_exec_ckpt_checkpointunlink);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 
 	return (0);
 }
@@ -1413,7 +1394,7 @@ static int message_handler_req_lib_ckpt_checkpointretentiondurationset (struct c
 	iovecs[0].iov_base = (char *)&req_exec_ckpt_checkpointretentiondurationset;
 	iovecs[0].iov_len = sizeof (req_exec_ckpt_checkpointretentiondurationset);
 
-	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+	assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 
 	return (0);
 }
@@ -1531,9 +1512,9 @@ printf ("|\n");
 #endif
 	if (iovecs[1].iov_len > 0) {
 		log_printf (LOG_LEVEL_DEBUG, "IOV_BASE is %p\n", iovecs[1].iov_base);
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);
@@ -1571,9 +1552,9 @@ static int message_handler_req_lib_ckpt_sectiondelete (struct conn_info *conn_in
 	iovecs[1].iov_len = req_lib_ckpt_sectiondelete->header.size - sizeof (struct req_lib_ckpt_sectiondelete);
 
 	if (iovecs[1].iov_len > 0) {
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);
@@ -1611,9 +1592,9 @@ static int message_handler_req_lib_ckpt_sectionexpirationtimeset (struct conn_in
 
 	if (iovecs[1].iov_len > 0) {
 		log_printf (LOG_LEVEL_DEBUG, "IOV_BASE is %p\n", iovecs[1].iov_base);
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);
@@ -1669,9 +1650,9 @@ static int message_handler_req_lib_ckpt_sectionwrite (struct conn_info *conn_inf
 
 //printf ("LIB writing checkpoint section is %s\n", ((char *)req_lib_ckpt_sectionwrite) + sizeof (struct req_lib_ckpt_sectionwrite));
 	if (iovecs[1].iov_len > 0) {
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);
@@ -1724,9 +1705,9 @@ static int message_handler_req_lib_ckpt_sectionoverwrite (struct conn_info *conn
 	iovecs[1].iov_len = req_lib_ckpt_sectionoverwrite->header.size - sizeof (struct req_lib_ckpt_sectionoverwrite);
 
 	if (iovecs[1].iov_len > 0) {
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);
@@ -1779,9 +1760,9 @@ static int message_handler_req_lib_ckpt_sectionread (struct conn_info *conn_info
 	iovecs[1].iov_len = req_lib_ckpt_sectionread->header.size - sizeof (struct req_lib_ckpt_sectionread);
 
 	if (iovecs[1].iov_len > 0) {
-		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 2, TOTEMPG_AGREED) == 0);
 	} else {
-		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW) == 0);
+		assert (totempg_mcast (iovecs, 1, TOTEMPG_AGREED) == 0);
 	}
 
 	return (0);

exec/clm.c

@@ -135,31 +135,26 @@ struct libais_handler clm_libais_handlers[] =
 		.libais_handler_fn			= message_handler_req_lib_activatepoll,
 		.response_size				= sizeof (struct res_lib_activatepoll),
 		.response_id				= MESSAGE_RES_LIB_ACTIVATEPOLL, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 1 */
 		.libais_handler_fn			= message_handler_req_clm_trackstart,
 		.response_size				= sizeof (struct res_clm_trackstart),
 		.response_id				= MESSAGE_RES_CLM_TRACKSTART, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 2 */
 		.libais_handler_fn			= message_handler_req_clm_trackstop,
 		.response_size				= sizeof (struct res_clm_trackstop),
 		.response_id				= MESSAGE_RES_CLM_TRACKSTOP, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 3 */
 		.libais_handler_fn			= message_handler_req_clm_nodeget,
 		.response_size				= sizeof (struct res_clm_nodeget),
 		.response_id				= MESSAGE_RES_CLM_NODEGET, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 4 */
 		.libais_handler_fn			= message_handler_req_clm_nodegetasync,
 		.response_size				= sizeof (struct res_clm_nodegetasync),
 		.response_id				= MESSAGE_RES_CLM_NODEGETCALLBACK, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	}
 };
 
@@ -386,7 +381,7 @@ static int clmNodeJoinSend (void)
 	req_exec_clm_iovec.iov_base = (char *)&req_exec_clm_nodejoin;
 	req_exec_clm_iovec.iov_len = sizeof (req_exec_clm_nodejoin);
 
-	result = totempg_mcast (&req_exec_clm_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_RECOVERY);
+	result = totempg_mcast (&req_exec_clm_iovec, 1, TOTEMPG_AGREED);
 
 	return (result);
 }

exec/evs.c

@@ -99,31 +99,26 @@ struct libais_handler evs_libais_handlers[] =
 		.libais_handler_fn			= message_handler_req_lib_activatepoll,
 		.response_size				= sizeof (struct res_lib_activatepoll),
 		.response_id				= MESSAGE_RES_LIB_ACTIVATEPOLL, // TODO RESPONSE
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 1 */
 		.libais_handler_fn			= message_handler_req_evs_join,
 		.response_size				= sizeof (struct res_lib_evs_join),
 		.response_id				= MESSAGE_RES_EVS_JOIN,
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 2 */
 		.libais_handler_fn			= message_handler_req_evs_leave,
 		.response_size				= sizeof (struct res_lib_evs_leave),
 		.response_id				= MESSAGE_RES_EVS_LEAVE,
-		.totempg_prio				= TOTEMPG_PRIO_RECOVERY
 	},
 	{ /* 3 */
 		.libais_handler_fn			= message_handler_req_evs_mcast_joined,
 		.response_size				= sizeof (struct res_lib_evs_mcast_joined),
 		.response_id				= MESSAGE_RES_EVS_MCAST_JOINED,
-		.totempg_prio				= TOTEMPG_PRIO_LOW
 	},
 	{ /* 4 */
 		.libais_handler_fn			= message_handler_req_evs_mcast_groups,
 		.response_size				= sizeof (struct res_lib_evs_mcast_groups),
 		.response_id				= MESSAGE_RES_EVS_MCAST_GROUPS,
-		.totempg_prio				= TOTEMPG_PRIO_LOW
 	}
 };
 
@@ -363,11 +358,10 @@ static int message_handler_req_evs_mcast_joined (struct conn_info *conn_info, vo
 	req_exec_evs_mcast_iovec[2].iov_base = &req_lib_evs_mcast_joined->msg;
 	req_exec_evs_mcast_iovec[2].iov_len = req_lib_evs_mcast_joined->msg_len;
 // TODO this doesn't seem to work for some reason	
-	send_ok = totempg_send_ok (req_lib_evs_mcast_joined->priority,
-		5000 + req_lib_evs_mcast_joined->msg_len); 
+	send_ok = totempg_send_ok (req_lib_evs_mcast_joined->msg_len); 
 
-		res = totempg_mcast (req_exec_evs_mcast_iovec, 3, TOTEMPG_AGREED,
-			req_lib_evs_mcast_joined->priority);
+	res = totempg_mcast (req_exec_evs_mcast_iovec, 3, TOTEMPG_AGREED);
+		// TODO
 	if (res == 0) {
 		error = EVS_OK;
 	} else {
@@ -413,10 +407,8 @@ static int message_handler_req_evs_mcast_groups (struct conn_info *conn_info, vo
 	req_exec_evs_mcast_iovec[2].iov_len = req_lib_evs_mcast_groups->msg_len;
 	
 // TODO this is wacky
-	send_ok = totempg_send_ok (req_lib_evs_mcast_groups->priority,
-		 5000 + req_lib_evs_mcast_groups->msg_len);
-	res = totempg_mcast (req_exec_evs_mcast_iovec, 3, TOTEMPG_AGREED,
-		req_lib_evs_mcast_groups->priority);
+	send_ok = totempg_send_ok (req_lib_evs_mcast_groups->msg_len);
+	res = totempg_mcast (req_exec_evs_mcast_iovec, 3, TOTEMPG_AGREED);
 	if (res == 0) {
 		error = EVS_OK;
 	}

exec/evt.c

@@ -96,49 +96,41 @@ static struct libais_handler evt_libais_handlers[] = {
 	.libais_handler_fn = 	message_handler_req_lib_activatepoll,
 	.response_size = 		sizeof(struct res_lib_activatepoll),
 	.response_id = 			MESSAGE_RES_LIB_ACTIVATEPOLL,
-	.totempg_prio = 			TOTEMPG_PRIO_RECOVERY
 	},
 	{
 	.libais_handler_fn = 	lib_evt_open_channel,
 	.response_size = 		sizeof(struct res_evt_channel_open),
 	.response_id = 			MESSAGE_RES_EVT_OPEN_CHANNEL,
-	.totempg_prio = 			TOTEMPG_PRIO_MED
 	},
 	{
 	.libais_handler_fn = 	lib_evt_close_channel,
 	.response_size = 		sizeof(struct res_evt_channel_close),
 	.response_id = 			MESSAGE_RES_EVT_CLOSE_CHANNEL,
-	.totempg_prio = 			TOTEMPG_PRIO_RECOVERY
 	},
 	{
 	.libais_handler_fn = 	lib_evt_event_subscribe,
 	.response_size = 		sizeof(struct res_evt_event_subscribe),
 	.response_id = 			MESSAGE_RES_EVT_SUBSCRIBE,
-	.totempg_prio = 			TOTEMPG_PRIO_RECOVERY
 	},
 	{
 	.libais_handler_fn = 	lib_evt_event_unsubscribe,
 	.response_size = 		sizeof(struct res_evt_event_unsubscribe),
 	.response_id = 			MESSAGE_RES_EVT_UNSUBSCRIBE,
-	.totempg_prio = 			TOTEMPG_PRIO_RECOVERY
 	},
 	{
 	.libais_handler_fn = 	lib_evt_event_publish,
 	.response_size = 		sizeof(struct res_evt_event_publish),
 	.response_id = 			MESSAGE_RES_EVT_PUBLISH,
-	.totempg_prio = 			TOTEMPG_PRIO_LOW
 	},
 	{
 	.libais_handler_fn = 	lib_evt_event_clear_retentiontime,
 	.response_size = 		sizeof(struct res_evt_event_clear_retentiontime),
 	.response_id = 			MESSAGE_REQ_EVT_CLEAR_RETENTIONTIME,
-	.totempg_prio = 			TOTEMPG_PRIO_MED
 	},
 	{
 	.libais_handler_fn = 	lib_evt_event_data_get,
 	.response_size = 		sizeof(struct lib_event_data),
 	.response_id = 			MESSAGE_RES_EVT_EVENT_DATA,
-	.totempg_prio = 			TOTEMPG_PRIO_RECOVERY
 	},
 };
 
@@ -844,7 +836,7 @@ static SaErrorT evt_open_channel(SaNameT *cn, SaUint8T flgs)
 	chn_iovec.iov_base = &cpkt;
 	chn_iovec.iov_len = cpkt.chc_head.size;
 	log_printf(CHAN_OPEN_DEBUG, "evt_open_channel: Send open mcast\n");
-	res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED);
+	res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED);
 	log_printf(CHAN_OPEN_DEBUG, "evt_open_channel: Open mcast result: %d\n",
 				res);
 	if (res != 0) {
@@ -879,7 +871,7 @@ static SaErrorT evt_close_channel(SaNameT *cn)
 	cpkt.u.chc_chan = *cn;
 	chn_iovec.iov_base = &cpkt;
 	chn_iovec.iov_len = cpkt.chc_head.size;
-	res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED);
+	res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED);
 	if (res != 0) {
 			ret = SA_ERR_SYSTEM;
 	}
@@ -1055,7 +1047,7 @@ static int send_next_retained(void *data)
 			evt->ed_event.led_head.id = MESSAGE_REQ_EXEC_EVT_RECOVERY_EVENTDATA;
 			chn_iovec.iov_base = &evt->ed_event;
 			chn_iovec.iov_len = evt->ed_event.led_head.size;
-			res = totempg_mcast(&chn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_RECOVERY);
+			res = totempg_mcast(&chn_iovec, 1, TOTEMPG_AGREED);
 
 			if (res != 0) {
 			/*
@@ -1071,7 +1063,7 @@ static int send_next_retained(void *data)
 		cpkt.chc_op = EVT_CONF_DONE;
 		chn_iovec.iov_base = &cpkt;
 		chn_iovec.iov_len = cpkt.chc_head.size;
-		res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_RECOVERY);
+		res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED);
 	}
 	tok_call_handle = 0;
 	return 0;
@@ -1095,7 +1087,7 @@ static void send_retained()
 		chn_iovec.iov_base = &cpkt;
 		chn_iovec.iov_len = cpkt.chc_head.size;
 		log_printf(RECOVERY_DEBUG, "No messages to send\n");
-		res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_RECOVERY);
+		res = totempg_mcast (&chn_iovec, 1, TOTEMPG_AGREED);
 	} else {
 		log_printf(RECOVERY_DEBUG, 
 					"Start sending retained messages\n");
@@ -1138,8 +1130,7 @@ static int send_next_open_count(void *data)
 			cpkt.u.chc_set_opens.chc_open_count = eci->esc_local_opens;
 			chn_iovec.iov_base = &cpkt;
 			chn_iovec.iov_len = cpkt.chc_head.size;
-			res = totempg_mcast(&chn_iovec, 1,TOTEMPG_AGREED,  
-				TOTEMPG_PRIO_RECOVERY);
+			res = totempg_mcast(&chn_iovec, 1,TOTEMPG_AGREED);
 
 			if (res != 0) {
 			/*
@@ -1155,8 +1146,7 @@ static int send_next_open_count(void *data)
 		cpkt.chc_op = EVT_OPEN_COUNT_DONE;
 		chn_iovec.iov_base = &cpkt;
 		chn_iovec.iov_len = cpkt.chc_head.size;
-		res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED,  
-												TOTEMPG_PRIO_RECOVERY);
+		res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED);
 	}
 	tok_call_handle = 0;
 	return 0;
@@ -1180,8 +1170,7 @@ static void send_open_count()
 		chn_iovec.iov_base = &cpkt;
 		chn_iovec.iov_len = cpkt.chc_head.size;
 		log_printf(RECOVERY_DEBUG, "No channels to send\n");
-		res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED,  
-											TOTEMPG_PRIO_RECOVERY);
+		res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED);
 	} else {
 		log_printf(RECOVERY_DEBUG, 
 					"Start sending open channel count\n");
@@ -2332,7 +2321,7 @@ static int lib_evt_event_publish(struct conn_info *conn_info, void *message)
 	 */
 	pub_iovec.iov_base = req;
 	pub_iovec.iov_len = req->led_head.size;
-	result = totempg_mcast (&pub_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_LOW);
+	result = totempg_mcast (&pub_iovec, 1, TOTEMPG_AGREED);
 	if (result != 0) {
 			error = SA_ERR_SYSTEM;
 	}
@@ -2377,7 +2366,7 @@ static int lib_evt_event_clear_retentiontime(struct conn_info *conn_info,
 	cpkt.u.chc_event_id = req->iec_event_id;
 	rtn_iovec.iov_base = &cpkt;
 	rtn_iovec.iov_len = cpkt.chc_head.size;
-	ret = totempg_mcast (&rtn_iovec, 1, TOTEMPG_AGREED, TOTEMPG_PRIO_MED);
+	ret = totempg_mcast (&rtn_iovec, 1, TOTEMPG_AGREED);
 	if (ret != 0) {
 			error = SA_ERR_SYSTEM;
 	}
@@ -2557,8 +2546,7 @@ static int evt_conf_change(
 										md->mn_last_evt_id & BASE_ID_MASK;
 				chn_iovec.iov_base = &cpkt;
 				chn_iovec.iov_len = cpkt.chc_head.size;
-				res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED,  
-														TOTEMPG_PRIO_RECOVERY);
+				res = totempg_mcast (&chn_iovec, 1,TOTEMPG_AGREED);
 				if (res != 0) {
 					log_printf(LOG_LEVEL_WARNING, 
 						"Unable to send event id to %s\n", 

exec/handlers.h

@@ -42,7 +42,6 @@ struct libais_handler {
 	int (*libais_handler_fn) (struct conn_info *conn_info, void *msg);
 	int response_size;
 	int response_id;
-	int totempg_prio;
 };
 
 struct service_handler {

exec/main.c

@@ -574,7 +574,7 @@ retry_recv:
 			 * deliver it, otherwise tell the library we are too busy
 			 */
 	
-			send_ok = totempg_send_ok (ais_service_handlers[service - 1]->libais_handlers[header->id].totempg_prio, 1000 + header->size);
+			send_ok = totempg_send_ok (1000 + header->size);
 			if (send_ok) {
 		//		*prio = 0;
 				res = ais_service_handlers[service - 1]->libais_handlers[header->id].libais_handler_fn(conn_info, header);

exec/totempg.c

@@ -429,8 +429,7 @@ int totempg_initialize (
 int totempg_mcast (
 	struct iovec *iovec,
 	int iov_len,
-	int guarantee,
-	int priority)
+	int guarantee)
 {
 	int res = 0;
 	struct totempg_mcast mcast;
@@ -548,7 +547,6 @@ for (i = 0; i < mcast_packed_msg_count; i++) {
  * Determine if a message of msg_size could be queued
  */
 int totempg_send_ok (
-	int priority,
 	int msg_size)
 {
 	int avail = 0;

exec/totempg.h

@@ -41,11 +41,6 @@
 
 #define MESSAGE_SIZE_MAX		256000
 
-#define TOTEMPG_PRIO_RECOVERY	0
-#define TOTEMPG_PRIO_HIGH		1
-#define TOTEMPG_PRIO_MED		2
-#define TOTEMPG_PRIO_LOW		3
-
 #define TOTEMPG_AGREED			0
 #define TOTEMPG_SAFE			1
 
@@ -111,14 +106,12 @@ int totempg_initialize (
 int totempg_mcast (
 	struct iovec *iovec,
 	int iov_len,
-	int guarantee,
-	int priority);
+	int guarantee);
 
 /*
  * Determine if a message of msg_size could be queued
  */
 int totempg_send_ok (
-	int priority,
 	int msg_size);
 
 enum totempg_callback_token_type {