[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