[Ocfs2-commits] zab commits r2021 - in trunk/fs/ocfs2: . cluster dlm

svn-commits at oss.oracle.com svn-commits at oss.oracle.com
Mon Mar 21 11:50:02 CST 2005


Author: zab
Signed-off-by: mfasheh
Date: 2005-03-21 11:50:00 -0600 (Mon, 21 Mar 2005)
New Revision: 2021

Modified:
   trunk/fs/ocfs2/cluster/tcp.c
   trunk/fs/ocfs2/cluster/tcp.h
   trunk/fs/ocfs2/dlm/dlmmod.c
   trunk/fs/ocfs2/dlm/dlmmod.h
   trunk/fs/ocfs2/ocfs.h
   trunk/fs/ocfs2/super.c
   trunk/fs/ocfs2/vote.c
Log:
introduce the ability to unregister net handlers so that when we mount after
unmount we don't fail to register duplicate handlers.
                                                                                
- use kref to track refs to the handlers
- pass a list in to registration; used to mass unregister
- get rid of HND_VAR_LEN and msg_len_ok, neither were used

Signed-off-by: mfasheh



Modified: trunk/fs/ocfs2/cluster/tcp.c
===================================================================
--- trunk/fs/ocfs2/cluster/tcp.c	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/cluster/tcp.c	2005-03-21 17:50:00 UTC (rev 2021)
@@ -148,12 +148,36 @@
 #define sk_state_change		state_change
 #endif
 
+struct net_msg_handler {
+	struct rb_node		nh_node;
+	u32			nh_max_len;
+	u32			nh_msg_type;
+	u32			nh_key;
+	net_msg_handler_func	*nh_func;
+	net_msg_handler_func	*nh_func_data;
+	struct kref		nh_kref;
+	struct list_head	nh_unregister_item;
+};
+
+typedef struct _net_status_ctxt {
+	u8 target_node;
+	struct list_head list;
+	enum net_system_error sys_status;
+	s32 status;
+	u64 msg_num;
+	wait_queue_head_t wq;
+	atomic_t woken;
+} net_status_ctxt;
+
+
 /* all this state should eventually be brought up by object activation
  * and tied to that object rather than being globally valid at insmod */
-static spinlock_t net_handler_lock = SPIN_LOCK_UNLOCKED;
 static spinlock_t net_status_lock = SPIN_LOCK_UNLOCKED;
-static LIST_HEAD(net_handlers);
 static LIST_HEAD(net_status_list);
+
+static rwlock_t net_handler_lock = RW_LOCK_UNLOCKED;
+static struct rb_root net_handler_tree = RB_ROOT;
+
 /* this lock is also grabbed from bh context, non-bh use _bh() locking */
 static spinlock_t net_active_lock = SPIN_LOCK_UNLOCKED;
 static LIST_HEAD(net_active_list);
@@ -170,7 +194,6 @@
 }
 
 /////////////////////
-static int net_add_handler(net_msg_handler *nmh);
 static struct socket *net_init_tcp_recv_sock(u16 port);
 static int net_receive_thread(void *data);
 static int net_receive(void);
@@ -182,26 +205,6 @@
 
 //////////////////////
 
-static void net_get_handler(net_msg_handler *nmh)
-{
-	atomic_inc(&nmh->refcnt);
-}
-
-static void __net_put_handler(net_msg_handler *nmh)
-{
-	assert_spin_locked(&net_handler_lock);
-
-	if (atomic_dec_and_test(&nmh->refcnt))
-		kfree(nmh);
-}
-
-static void net_put_handler(net_msg_handler *nmh)
-{
-	spin_lock(&net_handler_lock);
-	__net_put_handler(nmh);
-	spin_unlock(&net_handler_lock);
-}
-
 int net_start_rx_thread(struct nm_node *node)
 {
 	struct socket *sock;
@@ -290,108 +293,156 @@
 	return 0;
 }
 
+static int net_handler_cmp(struct net_msg_handler *nmh,
+			   u32 msg_type, u32 key)
+{
+	if (nmh->nh_msg_type != msg_type);
+		return nmh->nh_msg_type - msg_type;
+
+	return nmh->nh_key - key;
+}
+
+static struct net_msg_handler *
+net_handler_tree_lookup(u32 msg_type, u32 key, struct rb_node ***ret_p,
+			struct rb_node **ret_parent)
+{
+        struct rb_node **p = &net_handler_tree.rb_node;
+        struct rb_node *parent = NULL;
+	struct net_msg_handler *nmh, *ret = NULL;
+	int cmp;
+
+        while (*p) {
+                parent = *p;
+                nmh = rb_entry(parent, struct net_msg_handler, nh_node);
+		cmp = net_handler_cmp(nmh, msg_type, key);
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else if (cmp > 0)
+                        p = &(*p)->rb_right;
+                else {
+			ret = nmh;
+                        break;
+		}
+        }
+                                                                                
+        if (ret_p != NULL)
+                *ret_p = p;
+        if (ret_parent != NULL)
+                *ret_parent = parent;
+
+        return ret;
+}
+
+static void net_handler_kref_release(struct kref *kref)
+{
+	struct net_msg_handler *nmh;
+	nmh = container_of(kref, struct net_msg_handler, nh_kref);
+
+	kfree(nmh);
+}
+
 /* max_len is protection for the handler func.  incoming messages won't
  * be given to the handler if their payload is longer than the max. */
-int net_register_handler(u32 msg_type, u32 key, int flags, u32 max_len, 
-			 net_msg_handler_func *func, void *data)
+int net_register_handler(u32 msg_type, u32 key, u32 max_len,
+		         net_msg_handler_func *func, void *data,
+			 struct list_head *unreg_list)
 {
-	net_msg_handler *nmh;
-	int ret;
+	struct net_msg_handler *nmh = NULL;
+	struct rb_node **p, *parent;
+	int ret = 0;
 
 	if (max_len > NET_MAX_PAYLOAD_BYTES) {
 		netprintk("max_len for message handler out of range: %u\n", 
 			max_len);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out;
 	}
 
 	if (!msg_type) {
 		netprintk("no message type provided: %u, %p\n", msg_type, func);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out;
 
 	}
 	if (!func) {
 		netprintk("no message handler provided: %u, %p\n",
 		       msg_type, func);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out;
 	}
 
-       	nmh = kmalloc(sizeof(net_msg_handler), GFP_KERNEL);
-	if (!nmh) {
-		return -ENOMEM;
+       	nmh = kcalloc(1, sizeof(struct net_msg_handler), GFP_KERNEL);
+	if (nmh == NULL) {
+		ret = -ENOMEM;
+		goto out;
 	}
-	memset(nmh, 0, sizeof(net_msg_handler));
-	nmh->func = func;
-	nmh->data = data;
-	nmh->msg_type = msg_type;
-	nmh->max_len = max_len;
-	nmh->key = key;
-	spin_lock_init(&nmh->lock);
-	atomic_set(&nmh->refcnt, 0);
-	nmh->flags = flags;
-	INIT_LIST_HEAD(&nmh->list);
-	net_get_handler(nmh);
 
-	ret = net_add_handler(nmh);
-	if (ret) {
-		netprintk("message handler for type %u, key %u already exists!!!\n",
-		       msg_type, key);
+	nmh->nh_func = func;
+	nmh->nh_func_data = data;
+	nmh->nh_msg_type = msg_type;
+	nmh->nh_max_len = max_len;
+	nmh->nh_key = key;
+	/* the tree and list get this ref.. they're both removed in
+	 * unregister when this ref is dropped */
+	kref_init(&nmh->nh_kref, net_handler_kref_release);
+	INIT_LIST_HEAD(&nmh->nh_unregister_item);
+
+	write_lock(&net_handler_lock);
+	if (net_handler_tree_lookup(msg_type, key, &p, &parent))
+		ret = -EEXIST;
+	else {
+	        rb_link_node(&nmh->nh_node, parent, p);
+		rb_insert_color(&nmh->nh_node, &net_handler_tree);
+		list_add_tail(&nmh->nh_unregister_item, unreg_list);
 	}
+	write_unlock(&net_handler_lock);
+	if (ret)
+		goto out;
+
+out:
+	if (ret) 
+		kfree(nmh);
+
 	return ret;
 }
 EXPORT_SYMBOL(net_register_handler);
 
-
-
-static net_msg_handler * __net_lookup_handler(u32 msg_type, u32 key)
+void net_unregister_handler_list(struct list_head *list)
 {
-	net_msg_handler *ret;
-	struct list_head *iter;
+	struct list_head *pos, *n;
+	struct net_msg_handler *nmh;
 
-	assert_spin_locked(&net_handler_lock);
-
-	list_for_each(iter, &net_handlers) {
-		ret = list_entry(iter, net_msg_handler, list);
-		if (ret->msg_type == msg_type && ret->key == key) {
-			net_get_handler(ret);
-			return ret;
-		}
+	write_lock(&net_handler_lock);
+	list_for_each_safe(pos, n, list) {
+		nmh = list_entry(pos, struct net_msg_handler,
+				 nh_unregister_item);
+		rb_erase(&nmh->nh_node, &net_handler_tree);
+		list_del_init(&nmh->nh_unregister_item);
+		kref_put(&nmh->nh_kref, net_handler_kref_release);
 	}
-	return NULL;
+	write_unlock(&net_handler_lock);
 }
+EXPORT_SYMBOL(net_unregister_handler_list);
 
-net_msg_handler * net_lookup_handler(u32 msg_type, u32 key)
+static struct net_msg_handler *net_handler_get(u32 msg_type, u32 key)
 {
-	net_msg_handler *ret;
+	struct net_msg_handler *nmh;
 
-	spin_lock(&net_handler_lock);
-	ret = __net_lookup_handler(msg_type, key);
-	spin_unlock(&net_handler_lock);
+	read_lock(&net_handler_lock);
+	nmh = net_handler_tree_lookup(msg_type, key, NULL, NULL);
+	if (nmh)
+		kref_get(&nmh->nh_kref);
+	read_unlock(&net_handler_lock);
 
-	return ret;
+	return nmh;
 }
 
-static int net_add_handler(net_msg_handler *nmh)
+void net_handler_put(struct net_msg_handler *nmh)
 {
-	net_msg_handler *existing;
-	int ret;
+	kref_put(&nmh->nh_kref, net_handler_kref_release);
+}
 
-	spin_lock(&net_handler_lock);
-
-	existing = __net_lookup_handler(nmh->msg_type, nmh->key);
-	if (existing != NULL) {
-		__net_put_handler(existing);
-		ret = -EEXIST;
-		goto out;
-	}
-
-	list_add_tail(&nmh->list, &net_handlers);
-	ret = 0;
-
-out:
-	spin_unlock(&net_handler_lock);
-	return ret;
-}	      
-
 static int net_recv_tcp_msg(struct socket *sock, void *data, size_t len)
 {
 	int ret;
@@ -950,7 +1001,7 @@
 {
 	int ret, handler_status;
 	enum net_system_error syserr;
-	net_msg_handler *hnd = NULL;
+	struct net_msg_handler *nmh = NULL;
 
 	netprintk("received message header... magic=%u type=%u key=%u\n", 
 		  hdr->magic, hdr->msg_type, hdr->key);
@@ -980,23 +1031,22 @@
 	/* find a handler for it */
 	ret = 0;
 	handler_status = 0;
-	hnd = net_lookup_handler(hdr->msg_type, hdr->key);
-	if (!hnd) {
+	nmh = net_handler_get(hdr->msg_type, hdr->key);
+	if (!nmh) {
 		syserr = NET_ERR_NO_HNDLR;
 		goto out_respond;
 	}
 
 	syserr = NET_ERR_NONE;
 
-	spin_lock(&hnd->lock);
-	if (hdr->data_len > hnd->max_len)
+	if (hdr->data_len > nmh->nh_max_len)
 		syserr = NET_ERR_OVERFLOW;
-	spin_unlock(&hnd->lock);
 
 	if (syserr != NET_ERR_NONE)
 		goto out_respond;
 
-	handler_status = (hnd->func)(hdr, sizeof(net_msg) + hdr->data_len, hnd->data);
+	handler_status = (nmh->nh_func)(hdr, sizeof(net_msg) + hdr->data_len,
+				     nmh->nh_func_data);
 
 out_respond:
 	/* this destroys the hdr, so don't use it after this */
@@ -1006,8 +1056,8 @@
 		  handler_status, syserr, ret);
 
 out:
-	if (hnd)
-		net_put_handler(hnd);
+	if (nmh)
+		net_handler_put(nmh);
 	return ret;
 }
 

Modified: trunk/fs/ocfs2/cluster/tcp.h
===================================================================
--- trunk/fs/ocfs2/cluster/tcp.h	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/cluster/tcp.h	2005-03-21 17:50:00 UTC (rev 2021)
@@ -109,46 +109,12 @@
 
 typedef int (net_msg_handler_func)(net_msg *msg, u32 len, void *data);
 
-typedef struct _net_msg_handler
-{
-	struct list_head list;
-	u32 msg_type;
-	u32 key;
-	net_msg_handler_func *func;
-	void *data;
-	u32 max_len;
-	spinlock_t lock;
-	atomic_t refcnt;
-	int flags;
-} net_msg_handler;
-
-typedef struct _net_status_ctxt
-{
-	u8 target_node;
-	struct list_head list;
-	enum net_system_error sys_status;
-	s32 status;
-	u64 msg_num;
-	wait_queue_head_t wq;
-	atomic_t woken;
-} net_status_ctxt;
-
 #define NET_MAX_PAYLOAD_BYTES  (4096 - sizeof(net_msg))
 
 /* RESERVED */
 #define NET_ALREADY_CONNECTED   (0xfff0)
 #define NET_UNKNOWN_HOST        (0xfff1)
 
-#define NET_HND_VAR_LEN   0x00000001
-
-static inline int net_handler_msg_len_ok(net_msg_handler *handler, u32 len)
-{
-	return ((handler->flags & NET_HND_VAR_LEN) ? 
-		len <= handler->max_len : 
-		len == handler->max_len);
-}
-
-
 /* TODO: figure this out.... */
 static inline int net_link_down(int err, struct socket *sock)
 {
@@ -186,16 +152,18 @@
 	NET_DRIVER_READY,
 };
 
-int net_register_handler(u32 msg_type, u32 key, int flags, 
-			 u32 max_len, net_msg_handler_func *func, void *data);
 int net_init_tcp_sock(struct inode *inode);
 int net_send_message(u32 msg_type, u32 key, void *data, u32 len,
 		     u8 target_node, int *status);
 int net_send_message_iov(u32 msg_type, u32 key, struct iovec *iov,
 			 size_t iovlen, u8 target_node, int *status);
 int net_broadcast_message(u32 msg_type, u32 key, void *data, u32 len, struct inode *group);
-net_msg_handler * net_lookup_handler(u32 msg_type, u32 key);
 
+int net_register_handler(u32 msg_type, u32 key, u32 max_len,
+			 net_msg_handler_func *func, void *data,
+			 struct list_head *unreg_list);
+void net_unregister_handler_list(struct list_head *list);
+
 int net_register_hb_callbacks(void);
 void net_unregister_hb_callbacks(void);
 int net_start_rx_thread(struct nm_node *node);

Modified: trunk/fs/ocfs2/dlm/dlmmod.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmmod.c	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/dlm/dlmmod.c	2005-03-21 17:50:00 UTC (rev 2021)
@@ -74,6 +74,7 @@
 static int dlm_assert_joined_handler(net_msg *msg, u32 len, void *data);
 static int dlm_cancel_join_handler(net_msg *msg, u32 len, void *data);
 static int dlm_exit_domain_handler(net_msg *msg, u32 len, void *data);
+static void dlm_unregister_domain_handlers(dlm_ctxt *dlm);
 
 static void __dlm_print_nodes(dlm_ctxt *dlm);
 
@@ -83,9 +84,8 @@
 static spinlock_t dlm_cookie_lock = SPIN_LOCK_UNLOCKED;
 static u64 dlm_next_cookie = 1;
 
+static LIST_HEAD(dlm_join_handlers);
 
-
-
 typedef void (dlm_debug_func_t)(void);
 
 typedef struct _dlm_debug_funcs
@@ -145,37 +145,38 @@
 		entry->proc_fops = &dlm_debug_operations;
 }
 
+static void dlm_unregister_net_handlers(void)
+{
+	net_unregister_handler_list(&dlm_join_handlers);
+}
+
 static int dlm_register_net_handlers(void)
 {
-	int status;
+	int status = 0;
 
-	status = net_register_handler(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY, 0,
+	status = net_register_handler(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY,
 				      sizeof(dlm_query_join_request),
 				      dlm_query_join_handler,
-				      NULL);
+				      NULL, &dlm_join_handlers);
 	if (status)
 		goto bail;
 
-	status = net_register_handler(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY, 0,
+	status = net_register_handler(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY,
 				      sizeof(dlm_assert_joined),
 				      dlm_assert_joined_handler,
-				      NULL);
-	if (status) {
-		/* unregister handler here */
+				      NULL, &dlm_join_handlers);
+	if (status)
 		goto bail;
-	}
 
-	status = net_register_handler(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY, 0,
+	status = net_register_handler(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY,
 				      sizeof(dlm_cancel_join),
 				      dlm_cancel_join_handler,
-				      NULL);
-	if (status) {
-		/* unregister handler here */
-		/* unregister handler here */
-		goto bail;
-	}
+				      NULL, &dlm_join_handlers);
 
 bail:
+	if (status < 0)
+		dlm_unregister_net_handlers();
+
 	return status;
 }
 
@@ -221,6 +222,7 @@
  */
 static void __exit dlm_driver_exit (void)
 {
+	dlm_unregister_net_handlers();
 	dlmprintk0("Unloaded dlm Driver module\n");
 	return;
 }				/* dlm_driver_exit */
@@ -687,7 +689,7 @@
 	hb_unregister_callback(&dlm->dlm_hb_up);
 	hb_unregister_callback(&dlm->dlm_hb_down);
 
-	/* if the network code had any unregister calls, they would be here. */
+	dlm_unregister_domain_handlers(dlm);
 
 	dlm_complete_thread(dlm);
 
@@ -1288,6 +1290,11 @@
 	return status;
 }
 
+static void dlm_unregister_domain_handlers(dlm_ctxt *dlm)
+{
+	net_unregister_handler_list(&dlm->dlm_domain_handlers);
+}
+
 static int dlm_register_domain_handlers(dlm_ctxt *dlm)
 {
 	int status;
@@ -1306,57 +1313,59 @@
 	if (status)
 		goto bail;
 
-	status = net_register_handler(DLM_MASTER_REQUEST_MSG, dlm->key, 0, 
+	status = net_register_handler(DLM_MASTER_REQUEST_MSG, dlm->key,
 				      sizeof(dlm_master_request), 
 				      dlm_master_request_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
-	status = net_register_handler(DLM_ASSERT_MASTER_MSG, dlm->key, 0, 
+	status = net_register_handler(DLM_ASSERT_MASTER_MSG, dlm->key,
 				      sizeof(dlm_assert_master), 
 				      dlm_assert_master_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
-	status = net_register_handler(DLM_CREATE_LOCK_MSG, dlm->key, 0, 
+	status = net_register_handler(DLM_CREATE_LOCK_MSG, dlm->key,
 				      sizeof(dlm_create_lock), 
 				      dlm_create_lock_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
 	status = net_register_handler(DLM_CONVERT_LOCK_MSG, dlm->key, 
-				      NET_HND_VAR_LEN, 
 				      DLM_CONVERT_LOCK_MAX_LEN,
 				      dlm_convert_lock_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
 	status = net_register_handler(DLM_UNLOCK_LOCK_MSG, dlm->key, 
-				      NET_HND_VAR_LEN,
 				      DLM_UNLOCK_LOCK_MAX_LEN,
 				      dlm_unlock_lock_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
 	status = net_register_handler(DLM_PROXY_AST_MSG, dlm->key, 
-				      NET_HND_VAR_LEN,
 				      DLM_PROXY_AST_MAX_LEN,
 				      dlm_proxy_ast_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
 	if (status)
 		goto bail;
 
-	status = net_register_handler(DLM_EXIT_DOMAIN_MSG, dlm->key, 0,
+	status = net_register_handler(DLM_EXIT_DOMAIN_MSG, dlm->key,
 				      sizeof(dlm_exit_domain),
 				      dlm_exit_domain_handler,
-				      dlm);
+				      dlm, &dlm->dlm_domain_handlers);
+	if (status)
+		goto bail;
 
 bail:
+	if (status)
+		dlm_unregister_domain_handlers(dlm);
+
 	return status;
 }
 
@@ -1458,6 +1467,7 @@
 	INIT_LIST_HEAD(&dlm->reco.resources);
 	INIT_LIST_HEAD(&dlm->reco.received);
 	INIT_LIST_HEAD(&dlm->purge_list);
+	INIT_LIST_HEAD(&dlm->dlm_domain_handlers);
 
 	INIT_LIST_HEAD(&dlm->pending_asts);
 	INIT_LIST_HEAD(&dlm->pending_basts);

Modified: trunk/fs/ocfs2/dlm/dlmmod.h
===================================================================
--- trunk/fs/ocfs2/dlm/dlmmod.h	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/dlm/dlmmod.h	2005-03-21 17:50:00 UTC (rev 2021)
@@ -239,6 +239,8 @@
 	struct hb_callback_func dlm_hb_down;
 	struct task_struct *dlm_thread_task;
 	wait_queue_head_t dlm_thread_wq;
+
+	struct list_head	dlm_domain_handlers;
 };
 
 static inline void __dlm_set_joining_node(struct _dlm_ctxt *dlm,

Modified: trunk/fs/ocfs2/ocfs.h
===================================================================
--- trunk/fs/ocfs2/ocfs.h	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/ocfs.h	2005-03-21 17:50:00 UTC (rev 2021)
@@ -396,6 +396,8 @@
 
 	struct hb_callback_func	osb_hb_up;
 	struct hb_callback_func	osb_hb_down;
+
+	struct list_head	osb_net_handlers;
 };
 
 typedef struct _ocfs_global_ctxt

Modified: trunk/fs/ocfs2/super.c
===================================================================
--- trunk/fs/ocfs2/super.c	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/super.c	2005-03-21 17:50:00 UTC (rev 2021)
@@ -1014,6 +1014,8 @@
 
 	ocfs_release_system_inodes(osb);
 
+	ocfs2_unregister_net_handlers(osb);
+
 	ocfs2_dlm_shutdown(osb);
 
 	ocfs2_clear_hb_callbacks(osb);
@@ -1070,6 +1072,7 @@
 
 	LOG_ENTRY ();
 
+	INIT_LIST_HEAD(&osb->osb_net_handlers);
 	
 	osb->vol_label = kmalloc(64, GFP_KERNEL);
 	if (!osb->vol_label) {

Modified: trunk/fs/ocfs2/vote.c
===================================================================
--- trunk/fs/ocfs2/vote.c	2005-03-21 00:29:48 UTC (rev 2020)
+++ trunk/fs/ocfs2/vote.c	2005-03-21 17:50:00 UTC (rev 2021)
@@ -806,10 +806,23 @@
 	return status;
 }
 
+void ocfs2_unregister_net_handlers(ocfs_super *osb)
+{
+	if (!osb->net_key)
+		return;
+
+	net_unregister_handler_list(&osb->osb_net_handlers);
+
+	if (!list_empty(&osb->net_response_list))
+		LOG_ERROR_STR("net response list not empty!\n");
+
+	osb->net_key = 0;
+}
+
 int ocfs2_register_net_handlers(ocfs_super *osb)
 {
-	int status;
 	int i = MAX_VOL_ID_LENGTH - sizeof(osb->net_key);
+	int status = 0;
 
 	memcpy(&osb->net_key, &osb->uuid[i], sizeof(osb->net_key));
 	osb->net_response_ids = 0;
@@ -818,42 +831,27 @@
 
 	status = net_register_handler(OCFS2_MESSAGE_TYPE_RESPONSE,
 				      osb->net_key,
-				      0,
 				      sizeof(ocfs2_response_msg),
 				      ocfs2_handle_response_message,
-				      osb);
-	if (status < 0) {
+				      osb, &osb->osb_net_handlers);
+	if (status) {
 		LOG_ERROR_STATUS(status);
 		goto bail;
 	}
 
 	status = net_register_handler(OCFS2_MESSAGE_TYPE_VOTE,
 				      osb->net_key,
-				      0,
 				      sizeof(ocfs2_vote_msg),
 				      ocfs2_handle_vote_message,
-				      osb);
-	if (status < 0) {
-		/* TODO: net_unregister here! */
+				      osb, &osb->osb_net_handlers);
+	if (status) {
 		LOG_ERROR_STATUS(status);
 		goto bail;
 	}
-
 bail:
 	if (status < 0)
-		osb->net_key = 0;
+		ocfs2_unregister_net_handlers(osb);
 
 	return status;
 }
 
-void ocfs2_unregister_net_handlers(ocfs_super *osb)
-{
-	if (!osb->net_key)
-		return;
-
-	/* TODO: net_unregister here! */
-	/* TODO: net_unregister here! */
-
-	if (!list_empty(&osb->net_response_list))
-		LOG_ERROR_STR("net response list not empty!\n");
-}



More information about the Ocfs2-commits mailing list