[Ocfs2-commits] manish commits r2348 - in trunk/fs/ocfs2: . cluster
dlm
svn-commits at oss.oracle.com
svn-commits at oss.oracle.com
Wed Jun 1 17:07:52 CDT 2005
Author: manish
Signed-off-by: mfasheh
Signed-off-by: zab
Date: 2005-06-01 17:07:51 -0500 (Wed, 01 Jun 2005)
New Revision: 2348
Modified:
trunk/fs/ocfs2/cluster/net_proc.c
trunk/fs/ocfs2/cluster/nodemanager.c
trunk/fs/ocfs2/cluster/nodemanager.h
trunk/fs/ocfs2/cluster/tcp.c
trunk/fs/ocfs2/cluster/tcp.h
trunk/fs/ocfs2/cluster/tcp_internal.h
trunk/fs/ocfs2/dlm/dlmast.c
trunk/fs/ocfs2/dlm/dlmcommon.h
trunk/fs/ocfs2/dlm/dlmconvert.c
trunk/fs/ocfs2/dlm/dlmdomain.c
trunk/fs/ocfs2/dlm/dlmlock.c
trunk/fs/ocfs2/dlm/dlmmaster.c
trunk/fs/ocfs2/dlm/dlmrecovery.c
trunk/fs/ocfs2/dlm/dlmunlock.c
trunk/fs/ocfs2/vote.c
Log:
Move net functions into our own namespace
Signed-off-by: mfasheh
Signed-off-by: zab
Modified: trunk/fs/ocfs2/cluster/net_proc.c
===================================================================
--- trunk/fs/ocfs2/cluster/net_proc.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/net_proc.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -34,30 +34,30 @@
#include "tcp_internal.h"
-static spinlock_t net_proc_lock = SPIN_LOCK_UNLOCKED;
+static spinlock_t o2net_proc_lock = SPIN_LOCK_UNLOCKED;
static LIST_HEAD(sock_containers);
static LIST_HEAD(send_tracking);
-void net_proc_add_nst(struct net_send_tracking *nst)
+void o2net_proc_add_nst(struct o2net_send_tracking *nst)
{
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
list_add(&nst->st_net_proc_item, &send_tracking);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
}
-void net_proc_del_nst(struct net_send_tracking *nst)
+void o2net_proc_del_nst(struct o2net_send_tracking *nst)
{
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
if (!list_empty(&nst->st_net_proc_item))
list_del_init(&nst->st_net_proc_item);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
}
-struct net_send_tracking *next_nst(struct net_send_tracking *nst_start)
+struct o2net_send_tracking *next_nst(struct o2net_send_tracking *nst_start)
{
- struct net_send_tracking *nst, *ret = NULL;
+ struct o2net_send_tracking *nst, *ret = NULL;
- assert_spin_locked(&net_proc_lock);
+ assert_spin_locked(&o2net_proc_lock);
list_for_each_entry(nst, &nst_start->st_net_proc_item,
st_net_proc_item) {
@@ -77,35 +77,35 @@
static void *nst_seq_start(struct seq_file *seq, loff_t *pos)
{
- struct net_send_tracking *nst, *dummy_nst = seq->private;
+ struct o2net_send_tracking *nst, *dummy_nst = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
nst = next_nst(dummy_nst);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return nst;
}
static void *nst_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
- struct net_send_tracking *nst, *dummy_nst = seq->private;
+ struct o2net_send_tracking *nst, *dummy_nst = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
nst = next_nst(dummy_nst);
list_del_init(&dummy_nst->st_net_proc_item);
if (nst)
list_add(&dummy_nst->st_net_proc_item,
&nst->st_net_proc_item);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return nst; /* unused, just needs to be null when done */
}
static int nst_seq_show(struct seq_file *seq, void *v)
{
- struct net_send_tracking *nst, *dummy_nst = seq->private;
+ struct o2net_send_tracking *nst, *dummy_nst = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
nst = next_nst(dummy_nst);
if (nst != NULL) {
@@ -131,7 +131,7 @@
nst->st_status_time.tv_usec);
}
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return 0;
}
@@ -149,11 +149,11 @@
static int nst_fop_open(struct inode *inode, struct file *file)
{
- struct net_send_tracking *dummy_nst;
+ struct o2net_send_tracking *dummy_nst;
struct seq_file *seq;
int ret;
- dummy_nst = kmalloc(sizeof(struct net_send_tracking), GFP_KERNEL);
+ dummy_nst = kmalloc(sizeof(struct o2net_send_tracking), GFP_KERNEL);
if (dummy_nst == NULL) {
ret = -ENOMEM;
goto out;
@@ -166,7 +166,7 @@
seq = file->private_data;
seq->private = dummy_nst;
- net_proc_add_nst(dummy_nst);
+ o2net_proc_add_nst(dummy_nst);
dummy_nst = NULL;
@@ -178,9 +178,9 @@
static int nst_fop_release(struct inode *inode, struct file *file)
{
struct seq_file *seq = file->private_data;
- struct net_send_tracking *dummy_nst = seq->private;
+ struct o2net_send_tracking *dummy_nst = seq->private;
- net_proc_del_nst(dummy_nst);
+ o2net_proc_del_nst(dummy_nst);
return seq_release_private(inode, file);
}
@@ -192,24 +192,25 @@
.release = nst_fop_release,
};
-void net_proc_add_sc(struct net_sock_container *sc)
+void o2net_proc_add_sc(struct o2net_sock_container *sc)
{
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
list_add(&sc->sc_net_proc_item, &sock_containers);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
}
-void net_proc_del_sc(struct net_sock_container *sc)
+
+void o2net_proc_del_sc(struct o2net_sock_container *sc)
{
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
list_del_init(&sc->sc_net_proc_item);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
}
-struct net_sock_container *next_sc(struct net_sock_container *sc_start)
+struct o2net_sock_container *next_sc(struct o2net_sock_container *sc_start)
{
- struct net_sock_container *sc, *ret = NULL;
+ struct o2net_sock_container *sc, *ret = NULL;
- assert_spin_locked(&net_proc_lock);
+ assert_spin_locked(&o2net_proc_lock);
list_for_each_entry(sc, &sc_start->sc_net_proc_item, sc_net_proc_item) {
/* discover the head of the list miscast as a sc */
@@ -228,34 +229,34 @@
static void *sc_seq_start(struct seq_file *seq, loff_t *pos)
{
- struct net_sock_container *sc, *dummy_sc = seq->private;
+ struct o2net_sock_container *sc, *dummy_sc = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
sc = next_sc(dummy_sc);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return sc;
}
static void *sc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
- struct net_sock_container *sc, *dummy_sc = seq->private;
+ struct o2net_sock_container *sc, *dummy_sc = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
sc = next_sc(dummy_sc);
list_del_init(&dummy_sc->sc_net_proc_item);
if (sc)
list_add(&dummy_sc->sc_net_proc_item, &sc->sc_net_proc_item);
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return sc; /* unused, just needs to be null when done */
}
static int sc_seq_show(struct seq_file *seq, void *v)
{
- struct net_sock_container *sc, *dummy_sc = seq->private;
+ struct o2net_sock_container *sc, *dummy_sc = seq->private;
- spin_lock(&net_proc_lock);
+ spin_lock(&o2net_proc_lock);
sc = next_sc(dummy_sc);
if (sc != NULL) {
@@ -289,7 +290,7 @@
}
- spin_unlock(&net_proc_lock);
+ spin_unlock(&o2net_proc_lock);
return 0;
}
@@ -307,11 +308,11 @@
static int sc_fop_open(struct inode *inode, struct file *file)
{
- struct net_sock_container *dummy_sc;
+ struct o2net_sock_container *dummy_sc;
struct seq_file *seq;
int ret;
- dummy_sc = kmalloc(sizeof(struct net_sock_container), GFP_KERNEL);
+ dummy_sc = kmalloc(sizeof(struct o2net_sock_container), GFP_KERNEL);
if (dummy_sc == NULL) {
ret = -ENOMEM;
goto out;
@@ -324,7 +325,7 @@
seq = file->private_data;
seq->private = dummy_sc;
- net_proc_add_sc(dummy_sc);
+ o2net_proc_add_sc(dummy_sc);
dummy_sc = NULL;
@@ -336,9 +337,9 @@
static int sc_fop_release(struct inode *inode, struct file *file)
{
struct seq_file *seq = file->private_data;
- struct net_sock_container *dummy_sc = seq->private;
+ struct o2net_sock_container *dummy_sc = seq->private;
- net_proc_del_sc(dummy_sc);
+ o2net_proc_del_sc(dummy_sc);
return seq_release_private(inode, file);
}
@@ -353,14 +354,14 @@
#define SC_PROC_NAME "sock_containers"
#define NST_PROC_NAME "send_tracking"
-void net_proc_exit(struct proc_dir_entry *parent)
+void o2net_proc_exit(struct proc_dir_entry *parent)
{
remove_proc_entry(SC_PROC_NAME, parent);
remove_proc_entry(NST_PROC_NAME, parent);
}
-EXPORT_SYMBOL_GPL(net_proc_exit);
+EXPORT_SYMBOL_GPL(o2net_proc_exit);
-int net_proc_init(struct proc_dir_entry *parent)
+int o2net_proc_init(struct proc_dir_entry *parent)
{
struct proc_dir_entry *proc_sc = NULL, *proc_nst = NULL;
int ret;
@@ -382,4 +383,4 @@
return ret;
}
-EXPORT_SYMBOL_GPL(net_proc_init);
+EXPORT_SYMBOL_GPL(o2net_proc_init);
Modified: trunk/fs/ocfs2/cluster/nodemanager.c
===================================================================
--- trunk/fs/ocfs2/cluster/nodemanager.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/nodemanager.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -394,14 +394,14 @@
/* bring up the rx thread if we're setting the new local
* node. XXX make sure port/addr are set */
if (tmp && !cluster->cl_has_local) {
- ret = net_start_rx_thread(node);
+ ret = o2net_start_rx_thread(node);
if (ret)
return ret;
}
if (!tmp && cluster->cl_has_local &&
cluster->cl_local_node == node->nd_num) {
- net_stop_rx_thread(node);
+ o2net_stop_rx_thread(node);
cluster->cl_local_node = 0;
}
@@ -565,13 +565,13 @@
struct nm_node *node = to_nm_node(item);
struct nm_cluster *cluster = to_nm_cluster(group->cg_item.ci_parent);
- net_detach_sc(NULL, node);
+ o2net_detach_sc(NULL, node);
if (cluster->cl_has_local &&
(cluster->cl_local_node == node->nd_num)) {
cluster->cl_has_local = 0;
cluster->cl_local_node = NM_MAX_NODES;
- net_stop_rx_thread(node);
+ o2net_stop_rx_thread(node);
}
/* XXX call into net to stop this node from trading messages */
@@ -736,11 +736,11 @@
unregister_sysctl_table(ocfs2_table_header);
/* XXX sync with hb callbacks and shut down hb? */
- net_unregister_hb_callbacks();
+ o2net_unregister_hb_callbacks();
configfs_unregister_subsystem(&nm_cluster_group.cs_subsys);
nm_remove_proc(nm_proc);
mlog_remove_proc(nm_proc);
- net_proc_exit(nm_proc);
+ o2net_proc_exit(nm_proc);
remove_proc_entry(NM_PROC_PATH, NULL);
}
@@ -798,7 +798,7 @@
goto out;
}
- ret = net_register_hb_callbacks();
+ ret = o2net_register_hb_callbacks();
if (ret)
goto out_sysctl;
@@ -820,7 +820,7 @@
if (ret)
goto out_remove;
- ret = net_proc_init(nm_proc);
+ ret = o2net_proc_init(nm_proc);
if (ret)
goto out_mlog;
@@ -835,7 +835,7 @@
out_subsys:
configfs_unregister_subsystem(&nm_cluster_group.cs_subsys);
out_callbacks:
- net_unregister_hb_callbacks();
+ o2net_unregister_hb_callbacks();
out_sysctl:
unregister_sysctl_table(ocfs2_table_header);
out:
Modified: trunk/fs/ocfs2/cluster/nodemanager.h
===================================================================
--- trunk/fs/ocfs2/cluster/nodemanager.h 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/nodemanager.h 2005-06-01 22:07:51 UTC (rev 2348)
@@ -58,7 +58,7 @@
/* protected by nd_lock. It isn't so hot that we have all these
* net-private things out here in nodemanager.h. */
- struct net_sock_container *nd_sc;
+ struct o2net_sock_container *nd_sc;
/* threads waiting for an sc to arrive wait on the wq for generation
* to increase. it is increased when a connecting socket succeeds
* or fails or when an accepted socket is attached. */
Modified: trunk/fs/ocfs2/cluster/tcp.c
===================================================================
--- trunk/fs/ocfs2/cluster/tcp.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/tcp.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -83,6 +83,8 @@
#include <linux/kthread.h>
#include <linux/kref.h>
+#include <asm/uaccess.h>
+
#include "heartbeat.h"
#include "tcp.h"
#include "nodemanager.h"
@@ -115,49 +117,50 @@
mlog(ML_SOCKET, __sc_fmt fmt, __sc_args , ##args); \
} while (0)
-static rwlock_t net_handler_lock = RW_LOCK_UNLOCKED;
-static struct rb_root net_handler_tree = RB_ROOT;
+static rwlock_t o2net_handler_lock = RW_LOCK_UNLOCKED;
+static struct rb_root o2net_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);
-static LIST_HEAD(net_detach_list);
-static LIST_HEAD(net_attach_list);
+static spinlock_t o2net_active_lock = SPIN_LOCK_UNLOCKED;
+static LIST_HEAD(o2net_active_list);
+static LIST_HEAD(o2net_detach_list);
+static LIST_HEAD(o2net_attach_list);
/* XXX someday we'll need better accounting */
-static struct task_struct *net_recv_task = NULL;
+static struct task_struct *o2net_recv_task = NULL;
/////////////////////
-static struct socket *net_init_tcp_recv_sock(u16 port);
-static int net_receive_thread(void *data);
-static int net_receive(void);
-static void net_try_accept(struct socket *sock);
-static int net_process_message(struct nm_node *node, struct socket *sock,
- net_msg *hdr);
+static struct socket *o2net_init_tcp_recv_sock(u16 port);
+static int o2net_receive_thread(void *data);
+static int o2net_receive(void);
+static void o2net_try_accept(struct socket *sock);
+static int o2net_process_message(struct nm_node *node, struct socket *sock,
+ o2net_msg *hdr);
-static void net_data_ready(struct sock *sk, int bytes);
-static int net_sc_from_node(struct nm_node *node,
- struct net_sock_container **sc_ret);
-static int net_attach_sc(struct net_sock_container *sc);
-static void net_finish_connect(struct nm_node *node);
-static struct net_sock_container *sc_alloc(struct nm_node *node, int from_conn);
-static void net_state_change(struct sock *sk);
-static void net_complete_nodes_nsw(struct nm_node *node);
+static void o2net_data_ready(struct sock *sk, int bytes);
+static int o2net_sc_from_node(struct nm_node *node,
+ struct o2net_sock_container **sc_ret);
+static int o2net_attach_sc(struct o2net_sock_container *sc);
+static void o2net_finish_connect(struct nm_node *node);
+static struct o2net_sock_container *sc_alloc(struct nm_node *node,
+ int from_conn);
+static void o2net_state_change(struct sock *sk);
+static void o2net_complete_nodes_nsw(struct nm_node *node);
//////////////////////
-int net_start_rx_thread(struct nm_node *node)
+int o2net_start_rx_thread(struct nm_node *node)
{
struct socket *sock;
int ret = 0;
BUG_ON(node->nd_rx_thread != NULL);
- BUG_ON(net_recv_task != NULL);
+ BUG_ON(o2net_recv_task != NULL);
/* if the thread was setting up the rx socket we'd like to have it
* communicate errors back to us here. us setting up the socket
* and passing it to the thread is easier */
- sock = net_init_tcp_recv_sock(node->nd_ipv4_port);
+ sock = o2net_init_tcp_recv_sock(node->nd_ipv4_port);
if (IS_ERR(sock)) {
ret = PTR_ERR(sock);
sock = NULL;
@@ -166,8 +169,8 @@
mlog(ML_KTHREAD, "starting net receive thread...\n");
- node->nd_rx_thread = kthread_run(net_receive_thread, sock,
- "netrecv-%s", node->nd_name);
+ node->nd_rx_thread = kthread_run(o2net_receive_thread, sock,
+ "o2netrecv-%s", node->nd_name);
if (IS_ERR(node->nd_rx_thread)) {
ret = PTR_ERR(node->nd_rx_thread);
node->nd_rx_thread = NULL;
@@ -178,7 +181,7 @@
/* once the thread is running it has ownership of the sock */
sock = NULL;
- net_recv_task = node->nd_rx_thread;
+ o2net_recv_task = node->nd_rx_thread;
out:
if (sock)
@@ -186,13 +189,13 @@
return 0;
}
-void net_stop_rx_thread(struct nm_node *node)
+void o2net_stop_rx_thread(struct nm_node *node)
{
if (node->nd_rx_thread) {
mlog(ML_KTHREAD, "waiting for net thread to exit....\n");
kthread_stop(node->nd_rx_thread);
node->nd_rx_thread = NULL;
- net_recv_task = NULL;
+ o2net_recv_task = NULL;
}
/* XXX if we stop the thread we've cut off the rx path for all the
@@ -208,8 +211,8 @@
*/
static void sc_kref_release(struct kref *kref)
{
- struct net_sock_container *sc = container_of(kref,
- struct net_sock_container, sc_kref);
+ struct o2net_sock_container *sc = container_of(kref,
+ struct o2net_sock_container, sc_kref);
sclog(sc, "releasing\n");
if (sc->sc_sock) {
sock_release(sc->sc_sock);
@@ -218,14 +221,14 @@
kfree(sc);
}
-static void sc_put(struct net_sock_container *sc)
+static void sc_put(struct o2net_sock_container *sc)
{
sclog(sc, "put\n");
kref_put(&sc->sc_kref, sc_kref_release);
}
static void sk_register_callbacks(struct sock *sk,
- struct net_sock_container *sc)
+ struct o2net_sock_container *sc)
{
write_lock_bh(&sk->sk_callback_lock);
if (sk->sk_user_data != sc) {
@@ -233,14 +236,14 @@
kref_get(&sc->sc_kref);
sc->sc_data_ready = sk->sk_data_ready;
sc->sc_state_change = sk->sk_state_change;
- sk->sk_data_ready = net_data_ready;
- sk->sk_state_change = net_state_change;
+ sk->sk_data_ready = o2net_data_ready;
+ sk->sk_state_change = o2net_state_change;
}
write_unlock_bh(&sk->sk_callback_lock);
}
static int sk_unregister_callbacks(struct sock *sk,
- struct net_sock_container *sc)
+ struct o2net_sock_container *sc)
{
int ret = 0;
@@ -268,7 +271,7 @@
* specified instead of an sc such that any sc currently attached to the
* node will be detached.
*/
-void net_detach_sc(struct net_sock_container *sc, struct nm_node *node)
+void o2net_detach_sc(struct o2net_sock_container *sc, struct nm_node *node)
{
int nr_puts = 0;
struct sock *sk;
@@ -283,7 +286,7 @@
if (node->nd_sc) {
sc = node->nd_sc;
node->nd_sc = NULL;
- net_complete_nodes_nsw(node);
+ o2net_complete_nodes_nsw(node);
/* we have this ref now */
nr_puts++;
}
@@ -306,7 +309,7 @@
* where state_change puts us on the detach list. */
if (sc->sc_pending_connect) {
sc->sc_pending_connect = 0;
- net_finish_connect(node);
+ o2net_finish_connect(node);
}
}
if (!list_empty(&sc->sc_item)) {
@@ -324,7 +327,7 @@
NIPQUAD(node->nd_ipv4_address),
ntohs(node->nd_ipv4_port));
node->nd_sc = NULL;
- net_complete_nodes_nsw(node);
+ o2net_complete_nodes_nsw(node);
nr_puts++;
}
spin_unlock_bh(&node->nd_lock);
@@ -346,71 +349,72 @@
sc_put(sc);
}
}
-EXPORT_SYMBOL_GPL(net_detach_sc);
+EXPORT_SYMBOL_GPL(o2net_detach_sc);
-static void net_check_cb_lists(void)
+static void o2net_check_cb_lists(void)
{
- struct net_sock_container *sc;
+ struct o2net_sock_container *sc;
/* when we get the sc off the list we inherit the ref that was
* created when the sc was put on the list */
- spin_lock_bh(&net_active_lock);
- while (!list_empty(&net_attach_list)) {
- sc = list_entry(net_attach_list.next,
- struct net_sock_container, sc_item);
+ spin_lock_bh(&o2net_active_lock);
+ while (!list_empty(&o2net_attach_list)) {
+ sc = list_entry(o2net_attach_list.next,
+ struct o2net_sock_container, sc_item);
list_del_init(&sc->sc_item);
- spin_unlock_bh(&net_active_lock);
+ spin_unlock_bh(&o2net_active_lock);
sclog(sc, "found on connect list\n");
- net_attach_sc(sc);
+ o2net_attach_sc(sc);
sc_put(sc);
- spin_lock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
}
- while (!list_empty(&net_detach_list)) {
- sc = list_entry(net_detach_list.next,
- struct net_sock_container, sc_item);
+ while (!list_empty(&o2net_detach_list)) {
+ sc = list_entry(o2net_detach_list.next,
+ struct o2net_sock_container, sc_item);
list_del_init(&sc->sc_item);
- spin_unlock_bh(&net_active_lock);
+ spin_unlock_bh(&o2net_active_lock);
sclog(sc, "found on detach list\n");
- net_detach_sc(sc, NULL);
+ o2net_detach_sc(sc, NULL);
sc_put(sc);
- spin_lock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
}
- spin_unlock_bh(&net_active_lock);
+ spin_unlock_bh(&o2net_active_lock);
}
-static int net_rx_should_wake(struct socket *sock)
+static int o2net_rx_should_wake(struct socket *sock)
{
int empty;
- spin_lock_bh(&net_active_lock);
- empty = list_empty(&net_active_list) && list_empty(&net_detach_list) &&
- list_empty(&net_attach_list);
- spin_unlock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
+ empty = list_empty(&o2net_active_list) &&
+ list_empty(&o2net_detach_list) &&
+ list_empty(&o2net_attach_list);
+ spin_unlock_bh(&o2net_active_lock);
return !empty || tcp_sk(sock->sk)->accept_queue;
}
-static int net_receive_thread(void *data)
+static int o2net_receive_thread(void *data)
{
struct socket *sock = data;
mlog(ML_KTHREAD, "net thread running...\n");
while(!kthread_should_stop()) {
- net_try_accept(sock);
- net_check_cb_lists();
- net_receive();
+ o2net_try_accept(sock);
+ o2net_check_cb_lists();
+ o2net_receive();
wait_event_interruptible(*sock->sk->sk_sleep,
- net_rx_should_wake(sock) ||
+ o2net_rx_should_wake(sock) ||
kthread_should_stop());
}
@@ -419,7 +423,8 @@
return 0;
}
-static int net_handler_cmp(struct net_msg_handler *nmh, u32 msg_type, u32 key)
+static int o2net_handler_cmp(struct o2net_msg_handler *nmh, u32 msg_type,
+ u32 key)
{
int ret = memcmp(&nmh->nh_key, &key, sizeof(key));
@@ -429,19 +434,19 @@
return ret;
}
-static struct net_msg_handler *
-net_handler_tree_lookup(u32 msg_type, u32 key, struct rb_node ***ret_p,
- struct rb_node **ret_parent)
+static struct o2net_msg_handler *
+o2net_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 **p = &o2net_handler_tree.rb_node;
struct rb_node *parent = NULL;
- struct net_msg_handler *nmh, *ret = NULL;
+ struct o2net_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);
+ nmh = rb_entry(parent, struct o2net_msg_handler, nh_node);
+ cmp = o2net_handler_cmp(nmh, msg_type, key);
if (cmp < 0)
p = &(*p)->rb_left;
@@ -461,25 +466,25 @@
return ret;
}
-static void net_handler_kref_release(struct kref *kref)
+static void o2net_handler_kref_release(struct kref *kref)
{
- struct net_msg_handler *nmh;
- nmh = container_of(kref, struct net_msg_handler, nh_kref);
+ struct o2net_msg_handler *nmh;
+ nmh = container_of(kref, struct o2net_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, u32 max_len,
- net_msg_handler_func *func, void *data,
- struct list_head *unreg_list)
+int o2net_register_handler(u32 msg_type, u32 key, u32 max_len,
+ o2net_msg_handler_func *func, void *data,
+ struct list_head *unreg_list)
{
- struct net_msg_handler *nmh = NULL;
+ struct o2net_msg_handler *nmh = NULL;
struct rb_node **p, *parent;
int ret = 0;
- if (max_len > NET_MAX_PAYLOAD_BYTES) {
+ if (max_len > O2NET_MAX_PAYLOAD_BYTES) {
mlog(0, "max_len for message handler out of range: %u\n",
max_len);
ret = -EINVAL;
@@ -499,7 +504,7 @@
goto out;
}
- nmh = kcalloc(1, sizeof(struct net_msg_handler), GFP_KERNEL);
+ nmh = kcalloc(1, sizeof(struct o2net_msg_handler), GFP_KERNEL);
if (nmh == NULL) {
ret = -ENOMEM;
goto out;
@@ -512,26 +517,26 @@
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);
+ kref_init(&nmh->nh_kref, o2net_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))
+ write_lock(&o2net_handler_lock);
+ if (o2net_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);
+ rb_insert_color(&nmh->nh_node, &o2net_handler_tree);
list_add_tail(&nmh->nh_unregister_item, unreg_list);
mlog(ML_TCP, "registered handler func %p type %u key %08x\n",
func, msg_type, key);
/* we've had some trouble with handlers seemingly vanishing. */
- mlog_bug_on_msg(net_handler_tree_lookup(msg_type, key, &p,
- &parent) == NULL,
+ mlog_bug_on_msg(o2net_handler_tree_lookup(msg_type, key, &p,
+ &parent) == NULL,
"couldn't find handler we *just* registerd "
"for type %u key %08x\n", msg_type, key);
}
- write_unlock(&net_handler_lock);
+ write_unlock(&o2net_handler_lock);
if (ret)
goto out;
@@ -541,46 +546,46 @@
return ret;
}
-EXPORT_SYMBOL_GPL(net_register_handler);
+EXPORT_SYMBOL_GPL(o2net_register_handler);
-void net_unregister_handler_list(struct list_head *list)
+void o2net_unregister_handler_list(struct list_head *list)
{
struct list_head *pos, *n;
- struct net_msg_handler *nmh;
+ struct o2net_msg_handler *nmh;
- write_lock(&net_handler_lock);
+ write_lock(&o2net_handler_lock);
list_for_each_safe(pos, n, list) {
- nmh = list_entry(pos, struct net_msg_handler,
+ nmh = list_entry(pos, struct o2net_msg_handler,
nh_unregister_item);
mlog(ML_TCP, "unregistering handler func %p type %u key %08x\n",
nmh->nh_func, nmh->nh_msg_type, nmh->nh_key);
- rb_erase(&nmh->nh_node, &net_handler_tree);
+ rb_erase(&nmh->nh_node, &o2net_handler_tree);
list_del_init(&nmh->nh_unregister_item);
- kref_put(&nmh->nh_kref, net_handler_kref_release);
+ kref_put(&nmh->nh_kref, o2net_handler_kref_release);
}
- write_unlock(&net_handler_lock);
+ write_unlock(&o2net_handler_lock);
}
-EXPORT_SYMBOL_GPL(net_unregister_handler_list);
+EXPORT_SYMBOL_GPL(o2net_unregister_handler_list);
-static struct net_msg_handler *net_handler_get(u32 msg_type, u32 key)
+static struct o2net_msg_handler *o2net_handler_get(u32 msg_type, u32 key)
{
- struct net_msg_handler *nmh;
+ struct o2net_msg_handler *nmh;
- read_lock(&net_handler_lock);
- nmh = net_handler_tree_lookup(msg_type, key, NULL, NULL);
+ read_lock(&o2net_handler_lock);
+ nmh = o2net_handler_tree_lookup(msg_type, key, NULL, NULL);
if (nmh)
kref_get(&nmh->nh_kref);
- read_unlock(&net_handler_lock);
+ read_unlock(&o2net_handler_lock);
return nmh;
}
-static void net_handler_put(struct net_msg_handler *nmh)
+static void o2net_handler_put(struct o2net_msg_handler *nmh)
{
- kref_put(&nmh->nh_kref, net_handler_kref_release);
+ kref_put(&nmh->nh_kref, o2net_handler_kref_release);
}
-static int net_recv_tcp_msg(struct socket *sock, void *data, size_t len)
+static int o2net_recv_tcp_msg(struct socket *sock, void *data, size_t len)
{
int ret;
mm_segment_t oldfs;
@@ -602,8 +607,8 @@
return ret;
}
-static int net_send_tcp_msg(struct socket *sock, struct iovec *iov,
- size_t iovlen, size_t total)
+static int o2net_send_tcp_msg(struct socket *sock, struct iovec *iov,
+ size_t iovlen, size_t total)
{
int ret;
mm_segment_t oldfs;
@@ -636,7 +641,7 @@
return ret;
}
-static int net_prep_nsw(struct nm_node *node, struct net_status_wait *nsw)
+static int o2net_prep_nsw(struct nm_node *node, struct o2net_status_wait *nsw)
{
int ret = 0;
@@ -664,17 +669,17 @@
if (ret == 0) {
init_waitqueue_head(&nsw->ns_wq);
- nsw->ns_sys_status = NET_ERR_NONE;
+ nsw->ns_sys_status = O2NET_ERR_NONE;
nsw->ns_status = 0;
}
return ret;
}
-static void net_complete_nsw_locked(struct nm_node *node,
- struct net_status_wait *nsw,
- enum net_system_error sys_status,
- s32 status)
+static void o2net_complete_nsw_locked(struct nm_node *node,
+ struct o2net_status_wait *nsw,
+ enum o2net_system_error sys_status,
+ s32 status)
{
assert_spin_locked(&node->nd_lock);
@@ -687,9 +692,10 @@
}
}
-static void net_complete_nsw(struct nm_node *node, struct net_status_wait *nsw,
- u64 id, enum net_system_error sys_status,
- s32 status)
+static void o2net_complete_nsw(struct nm_node *node,
+ struct o2net_status_wait *nsw,
+ u64 id, enum o2net_system_error sys_status,
+ s32 status)
{
spin_lock_bh(&node->nd_lock);
if (nsw == NULL) {
@@ -701,24 +707,24 @@
goto out;
}
- net_complete_nsw_locked(node, nsw, sys_status, status);
+ o2net_complete_nsw_locked(node, nsw, sys_status, status);
out:
spin_unlock_bh(&node->nd_lock);
return;
}
-static void net_complete_nodes_nsw(struct nm_node *node)
+static void o2net_complete_nodes_nsw(struct nm_node *node)
{
struct list_head *iter, *tmp;
unsigned int num_kills = 0;
- struct net_status_wait *nsw;
+ struct o2net_status_wait *nsw;
assert_spin_locked(&node->nd_lock);
list_for_each_safe(iter, tmp, &node->nd_status_list) {
- nsw = list_entry(iter, struct net_status_wait, ns_node_item);
- net_complete_nsw_locked(node, nsw, NET_ERR_DIED, 0);
+ nsw = list_entry(iter, struct o2net_status_wait, ns_node_item);
+ o2net_complete_nsw_locked(node, nsw, O2NET_ERR_DIED, 0);
num_kills++;
}
@@ -726,8 +732,8 @@
node->nd_num, num_kills);
}
-static int net_nsw_completed(struct nm_node * node,
- struct net_status_wait *nsw)
+static int o2net_nsw_completed(struct nm_node * node,
+ struct o2net_status_wait *nsw)
{
int completed;
spin_lock_bh(&node->nd_lock);
@@ -736,29 +742,28 @@
return completed;
}
-int net_send_message_iov(u32 msg_type, u32 key, struct iovec *caller_iov,
- size_t caller_iovlen, u8 target_node,
- int *status)
+int o2net_send_message_iov(u32 msg_type, u32 key, struct iovec *caller_iov,
+ size_t caller_iovlen, u8 target_node, int *status)
{
int ret;
- net_msg *msg = NULL;
+ o2net_msg *msg = NULL;
size_t i, iovlen, caller_bytes = 0;
struct iovec *iov = NULL;
- struct net_sock_container *sc = NULL;
+ struct o2net_sock_container *sc = NULL;
struct nm_node *node = NULL;
- struct net_status_wait nsw = {
+ struct o2net_status_wait nsw = {
.ns_node_item = LIST_HEAD_INIT(nsw.ns_node_item),
};
- struct net_send_tracking nst = {
+ struct o2net_send_tracking nst = {
.st_net_proc_item = LIST_HEAD_INIT(nst.st_net_proc_item),
.st_task = current,
.st_msg_type = msg_type,
.st_msg_key = key,
};
- BUG_ON(net_recv_task && (current == net_recv_task));
+ BUG_ON(o2net_recv_task && (current == o2net_recv_task));
- if (net_recv_task == NULL) {
+ if (o2net_recv_task == NULL) {
mlog(0, "attempt to tx without a setup rx thread\n");
ret = -ESRCH;
goto out;
@@ -773,7 +778,7 @@
for(i = 0; i < caller_iovlen; i++)
caller_bytes += caller_iov[i].iov_len;
- if (caller_bytes > NET_MAX_PAYLOAD_BYTES) {
+ if (caller_bytes > O2NET_MAX_PAYLOAD_BYTES) {
mlog(0, "total payload len %zu too large\n", caller_bytes);
ret = -EINVAL;
goto out;
@@ -792,10 +797,10 @@
}
nst.st_node = node;
- net_proc_add_nst(&nst);
+ o2net_proc_add_nst(&nst);
do_gettimeofday(&nst.st_sock_time);
- ret = net_sc_from_node(node, &sc);
+ ret = o2net_sc_from_node(node, &sc);
if (ret)
goto out;
@@ -810,25 +815,25 @@
goto out;
}
- msg = kmalloc(sizeof(net_msg), GFP_KERNEL);
+ msg = kmalloc(sizeof(o2net_msg), GFP_KERNEL);
if (!msg) {
- mlog(0, "failed to allocate a net_msg!\n");
+ mlog(0, "failed to allocate a o2net_msg!\n");
ret = -ENOMEM;
goto out;
}
- memset(msg, 0, sizeof(net_msg));
- msg->magic = NET_MSG_MAGIC;
+ memset(msg, 0, sizeof(o2net_msg));
+ msg->magic = O2NET_MSG_MAGIC;
msg->data_len = caller_bytes;
msg->msg_type = msg_type;
- msg->sys_status = NET_ERR_NONE;
+ msg->sys_status = O2NET_ERR_NONE;
msg->status = 0;
msg->key = key;
- iov[0].iov_len = sizeof(net_msg);
+ iov[0].iov_len = sizeof(o2net_msg);
iov[0].iov_base = msg;
memcpy(&iov[1], caller_iov, caller_iovlen * sizeof(struct iovec));
- ret = net_prep_nsw(node, &nsw);
+ ret = o2net_prep_nsw(node, &nsw);
if (ret)
goto out;
@@ -837,31 +842,31 @@
do_gettimeofday(&nst.st_send_time);
/* finally, convert the message header to network byte-order
* and send */
- net_msg_to_net(msg);
- ret = net_send_tcp_msg(sc->sc_sock, iov, iovlen,
- sizeof(net_msg) + caller_bytes);
- net_msg_to_host(msg); /* just swapping for printk, its unused now */
+ o2net_msg_to_net(msg);
+ ret = o2net_send_tcp_msg(sc->sc_sock, iov, iovlen,
+ sizeof(o2net_msg) + caller_bytes);
+ o2net_msg_to_host(msg); /* just swapping for printk, its unused now */
msglog(msg, "sending returned %d\n", ret);
if (ret < 0) {
- mlog(0, "error returned from net_send_tcp_msg=%d\n", ret);
+ mlog(0, "error returned from o2net_send_tcp_msg=%d\n", ret);
goto out;
}
/* wait on other node's handler */
do_gettimeofday(&nst.st_status_time);
- wait_event(nsw.ns_wq, net_nsw_completed(node, &nsw));
+ wait_event(nsw.ns_wq, o2net_nsw_completed(node, &nsw));
/* Note that we avoid overwriting the callers status return
* variable if a system error was reported on the other
* side. Callers beware. */
- ret = net_sys_err_to_errno(nsw.ns_sys_status);
+ ret = o2net_sys_err_to_errno(nsw.ns_sys_status);
if (status && !ret)
*status = nsw.ns_status;
mlog(0, "woken, returning system status %d, user status %d\n",
ret, nsw.ns_status);
out:
- net_proc_del_nst(&nst); /* must be before dropping sc and node */
+ o2net_proc_del_nst(&nst); /* must be before dropping sc and node */
if (sc)
sc_put(sc);
if (iov)
@@ -869,15 +874,15 @@
if (msg)
kfree(msg);
if (node) {
- net_complete_nsw(node, &nsw, 0, 0, 0);
+ o2net_complete_nsw(node, &nsw, 0, 0, 0);
nm_node_put(node);
}
return ret;
}
-EXPORT_SYMBOL_GPL(net_send_message_iov);
+EXPORT_SYMBOL_GPL(o2net_send_message_iov);
/*
- * net_send_message
+ * o2net_send_message
*
* - this is probably the function you are looking for
* - it will package up the message for you, verifying that
@@ -892,49 +897,49 @@
* already converted to host byteorder
* - status will not be set on return code != 0
*/
-int net_send_message(u32 msg_type, u32 key, void *data, u32 len,
- u8 target_node, int *status)
+int o2net_send_message(u32 msg_type, u32 key, void *data, u32 len,
+ u8 target_node, int *status)
{
struct iovec iov = {
.iov_base = data,
.iov_len = len,
};
- return net_send_message_iov(msg_type, key, &iov, 1,
- target_node, status);
+ return o2net_send_message_iov(msg_type, key, &iov, 1,
+ target_node, status);
}
-EXPORT_SYMBOL_GPL(net_send_message);
+EXPORT_SYMBOL_GPL(o2net_send_message);
-static int net_send_status_magic(struct socket *sock, net_msg *hdr,
- enum net_system_error syserr, int err)
+static int o2net_send_status_magic(struct socket *sock, o2net_msg *hdr,
+ enum o2net_system_error syserr, int err)
{
struct iovec iov = {
.iov_base = hdr,
- .iov_len = sizeof(net_msg),
+ .iov_len = sizeof(o2net_msg),
};
- BUG_ON(syserr >= NET_ERR_MAX);
+ BUG_ON(syserr >= O2NET_ERR_MAX);
/* leave other fields intact from the incoming message, msg_num
* in particular */
hdr->sys_status = syserr;
hdr->status = err;
- hdr->magic = NET_MSG_STATUS_MAGIC; // twiddle the magic
+ hdr->magic = O2NET_MSG_STATUS_MAGIC; // twiddle the magic
hdr->data_len = 0;
msglog(hdr, "about to send status magic %d\n", err);
/* hdr has been in host byteorder this whole time */
- net_msg_to_net(hdr);
- return net_send_tcp_msg(sock, &iov, 1, sizeof(net_msg));
+ o2net_msg_to_net(hdr);
+ return o2net_send_tcp_msg(sock, &iov, 1, sizeof(o2net_msg));
}
/* a callback would like the rx thread to do some work on its behalf
* in process context.. the callback has a ref from sk->user_data,
* we grab a ref as we put the sc on the list that the rx thread will
* inherit when it removes from the list */
-static void net_sc_list_add(struct net_sock_container *sc,
- struct list_head *list)
+static void o2net_sc_list_add(struct o2net_sock_container *sc,
+ struct list_head *list)
{
- assert_spin_locked(&net_active_lock);
+ assert_spin_locked(&o2net_active_lock);
if (list_empty(&sc->sc_item)) {
sclog(sc, "adding to list %p\n", list);
@@ -942,17 +947,17 @@
list_add_tail(&sc->sc_item, list);
}
- if (net_recv_task)
- wake_up_process(net_recv_task);
+ if (o2net_recv_task)
+ wake_up_process(o2net_recv_task);
}
/* teardown can race with these guys and stop them in their read lock..
* teardown will clear sk_user_data and reset the callbacks so that these
* guys can know to call them and not lose the event.. */
-static void net_data_ready(struct sock *sk, int bytes)
+static void o2net_data_ready(struct sock *sk, int bytes)
{
void (*ready)(struct sock *sk, int bytes);
- struct net_sock_container *sc;
+ struct o2net_sock_container *sc;
read_lock(&sk->sk_callback_lock);
sc = sk->sk_user_data;
@@ -963,15 +968,14 @@
sclog(sc, "data_ready hit\n");
- spin_lock(&net_active_lock);
- net_sc_list_add(sc, &net_active_list);
- spin_unlock(&net_active_lock);
+ spin_lock(&o2net_active_lock);
+ o2net_sc_list_add(sc, &o2net_active_list);
+ spin_unlock(&o2net_active_lock);
ready = sc->sc_data_ready;
out:
read_unlock(&sk->sk_callback_lock);
ready(sk, bytes);
-
}
/*
@@ -979,23 +983,23 @@
* them and call into the stack. we get the ref from their entry on
* the list.
*/
-static int net_receive(void)
+static int o2net_receive(void)
{
- struct net_sock_container *sc;
- net_msg *hdr;
+ struct o2net_sock_container *sc;
+ o2net_msg *hdr;
int err = 0, read_eagain, read_some;
void *data;
size_t datalen;
struct nm_node *node = NULL;
- spin_lock_bh(&net_active_lock);
- while (!list_empty(&net_active_list)) {
- sc = list_entry(net_active_list.next,
- struct net_sock_container, sc_item);
+ spin_lock_bh(&o2net_active_lock);
+ while (!list_empty(&o2net_active_list)) {
+ sc = list_entry(o2net_active_list.next,
+ struct o2net_sock_container, sc_item);
/* we now have the ref that adding created */
list_del_init(&sc->sc_item);
- spin_unlock_bh(&net_active_lock);
+ spin_unlock_bh(&o2net_active_lock);
sclog(sc, "found on active list\n");
@@ -1017,20 +1021,20 @@
goto done;
/* do we need more header? */
- if (sc->sc_page_off < sizeof(net_msg)) {
+ if (sc->sc_page_off < sizeof(o2net_msg)) {
data = page_address(sc->sc_page) + sc->sc_page_off;
- datalen = sizeof(net_msg) - sc->sc_page_off;
- err = net_recv_tcp_msg(sc->sc_sock, data, datalen);
+ datalen = sizeof(o2net_msg) - sc->sc_page_off;
+ err = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
if (err > 0) {
sc->sc_page_off += err;
read_some = 1;
/* only swab incoming here.. we can
* only get here once as we cross from
* being under to over */
- if (sc->sc_page_off == sizeof(net_msg)) {
+ if (sc->sc_page_off == sizeof(o2net_msg)) {
hdr = page_address(sc->sc_page);
- net_msg_to_host(hdr);
- if (hdr->data_len > NET_MAX_PAYLOAD_BYTES)
+ o2net_msg_to_host(hdr);
+ if (hdr->data_len > O2NET_MAX_PAYLOAD_BYTES)
err = -EOVERFLOW;
}
}
@@ -1041,7 +1045,7 @@
}
}
- if (sc->sc_page_off < sizeof(net_msg)) {
+ if (sc->sc_page_off < sizeof(o2net_msg)) {
/* oof, still don't have a header */
goto done;
}
@@ -1052,12 +1056,12 @@
msglog(hdr, "at page_off %zu\n", sc->sc_page_off);
/* do we need more payload? */
- if (sc->sc_page_off - sizeof(net_msg) < hdr->data_len) {
+ if (sc->sc_page_off - sizeof(o2net_msg) < hdr->data_len) {
/* need more payload */
data = page_address(sc->sc_page) + sc->sc_page_off;
- datalen = (sizeof(net_msg) + hdr->data_len) -
+ datalen = (sizeof(o2net_msg) + hdr->data_len) -
sc->sc_page_off;
- err = net_recv_tcp_msg(sc->sc_sock, data, datalen);
+ err = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
if (err > 0) {
read_some = 1;
sc->sc_page_off += err;
@@ -1069,10 +1073,10 @@
}
}
- if (sc->sc_page_off - sizeof(net_msg) == hdr->data_len) {
+ if (sc->sc_page_off - sizeof(o2net_msg) == hdr->data_len) {
/* whooo peee, we have a full message */
/* after calling this the message is toast */
- err = net_process_message(node, sc->sc_sock, hdr);
+ err = o2net_process_message(node, sc->sc_sock, hdr);
sc->sc_page_off = 0;
}
@@ -1092,82 +1096,81 @@
* as long as there may still be remaining data.
* data_ready might have been called after we saw eagain */
if (!err && read_some && !read_eagain) {
- spin_lock_bh(&net_active_lock);
- net_sc_list_add(sc, &net_active_list);
- spin_unlock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
+ o2net_sc_list_add(sc, &o2net_active_list);
+ spin_unlock_bh(&o2net_active_lock);
}
/* this exists to catch the framing errors, all other
* errors should come through state_change, really. */
if (err) {
sclog(sc, "saw err %d, closing\n", err);
- net_detach_sc(sc, NULL);
+ o2net_detach_sc(sc, NULL);
}
sc_put(sc);
- spin_lock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
}
- spin_unlock_bh(&net_active_lock);
+ spin_unlock_bh(&o2net_active_lock);
return 0;
}
/* if we get a message that the node has gone down then we detach its
* active socket. This will send error codes to any transmitters that
* were waiting for status replies on that node. */
-static void net_hb_node_down_cb(struct nm_node *node,
- int node_num,
- void *data)
+static void o2net_hb_node_down_cb(struct nm_node *node, int node_num,
+ void *data)
{
- net_detach_sc(NULL, node);
+ o2net_detach_sc(NULL, node);
}
-static struct hb_callback_func *net_hb_down = NULL;
-#define NET_HB_NODE_DOWN_PRI (0x1)
+static struct hb_callback_func *o2net_hb_down = NULL;
+#define O2NET_HB_NODE_DOWN_PRI (0x1)
-int net_register_hb_callbacks(void)
+int o2net_register_hb_callbacks(void)
{
- net_hb_down = kmalloc(sizeof(*net_hb_down), GFP_KERNEL);
- if (!net_hb_down)
+ o2net_hb_down = kmalloc(sizeof(*o2net_hb_down), GFP_KERNEL);
+ if (!o2net_hb_down)
return -ENOMEM;
- memset(net_hb_down, 0, sizeof(*net_hb_down));
+ memset(o2net_hb_down, 0, sizeof(*o2net_hb_down));
- hb_setup_callback(net_hb_down, HB_NODE_DOWN_CB,
- net_hb_node_down_cb, NULL, NET_HB_NODE_DOWN_PRI);
- return hb_register_callback(net_hb_down);
+ hb_setup_callback(o2net_hb_down, HB_NODE_DOWN_CB,
+ o2net_hb_node_down_cb, NULL, O2NET_HB_NODE_DOWN_PRI);
+ return hb_register_callback(o2net_hb_down);
}
-void net_unregister_hb_callbacks(void)
+void o2net_unregister_hb_callbacks(void)
{
int status;
- if (net_hb_down) {
- status = hb_unregister_callback(net_hb_down);
+ if (o2net_hb_down) {
+ status = hb_unregister_callback(o2net_hb_down);
if (status < 0)
mlog(ML_ERROR, "Status return %d unregistering "
"heartbeat callback!\n", status);
- kfree(net_hb_down);
- net_hb_down = NULL;
+ kfree(o2net_hb_down);
+ o2net_hb_down = NULL;
}
}
/* this returns -errno if the header was unknown or too large, etc.
* after this is called the buffer us reused for the next message */
-static int net_process_message(struct nm_node *node, struct socket *sock,
- net_msg *hdr)
+static int o2net_process_message(struct nm_node *node, struct socket *sock,
+ o2net_msg *hdr)
{
int ret, handler_status;
- enum net_system_error syserr;
- struct net_msg_handler *nmh = NULL;
+ enum o2net_system_error syserr;
+ struct o2net_msg_handler *nmh = NULL;
msglog(hdr, "processing message\n");
- if (hdr->magic == NET_MSG_STATUS_MAGIC) {
+ if (hdr->magic == O2NET_MSG_STATUS_MAGIC) {
/* special type for returning message status */
- net_complete_nsw(node, NULL, hdr->msg_num, hdr->sys_status,
- hdr->status);
+ o2net_complete_nsw(node, NULL, hdr->msg_num, hdr->sys_status,
+ hdr->status);
ret = 0;
goto out;
- } else if (hdr->magic != NET_MSG_MAGIC) {
+ } else if (hdr->magic != O2NET_MSG_MAGIC) {
msglog(hdr, "bad magic\n");
ret = -EINVAL;
goto out;
@@ -1176,35 +1179,35 @@
/* find a handler for it */
ret = 0;
handler_status = 0;
- nmh = net_handler_get(hdr->msg_type, hdr->key);
+ nmh = o2net_handler_get(hdr->msg_type, hdr->key);
if (!nmh) {
mlog(ML_TCP, "couldn't find handler for type %u key %08x\n",
hdr->msg_type, hdr->key);
- syserr = NET_ERR_NO_HNDLR;
+ syserr = O2NET_ERR_NO_HNDLR;
goto out_respond;
}
- syserr = NET_ERR_NONE;
+ syserr = O2NET_ERR_NONE;
if (hdr->data_len > nmh->nh_max_len)
- syserr = NET_ERR_OVERFLOW;
+ syserr = O2NET_ERR_OVERFLOW;
- if (syserr != NET_ERR_NONE)
+ if (syserr != O2NET_ERR_NONE)
goto out_respond;
- handler_status = (nmh->nh_func)(hdr, sizeof(net_msg) + hdr->data_len,
- nmh->nh_func_data);
+ handler_status = (nmh->nh_func)(hdr, sizeof(o2net_msg) + hdr->data_len,
+ nmh->nh_func_data);
out_respond:
/* this destroys the hdr, so don't use it after this */
- ret = net_send_status_magic(sock, hdr, syserr, handler_status);
+ ret = o2net_send_status_magic(sock, hdr, syserr, handler_status);
hdr = NULL;
mlog(0, "sending handler status %d, syserr %d returned %d\n",
handler_status, syserr, ret);
out:
if (nmh)
- net_handler_put(nmh);
+ o2net_handler_put(nmh);
return ret;
}
@@ -1213,12 +1216,12 @@
* is ready for business. Once it is attached to the node
* then transmitting paths can get ahold of it and send messages.
*/
-static int net_attach_sc(struct net_sock_container *sc)
+static int o2net_attach_sc(struct o2net_sock_container *sc)
{
struct sock *sk;
int ret = 0;
u8 this_node = nm_this_node(); /* :( */
- struct net_sock_container *detach = NULL;
+ struct o2net_sock_container *detach = NULL;
struct nm_node *node = sc->sc_node;
sclog(sc, "attaching with node %p\n", node);
@@ -1254,7 +1257,7 @@
/* resolve our pending connect before we drop the node lock */
if (sc->sc_pending_connect) {
sc->sc_pending_connect = 0;
- net_finish_connect(node);
+ o2net_finish_connect(node);
} else {
/* accepts arriving should wake sleepers, too */
atomic_inc(&node->nd_sc_generation);
@@ -1269,7 +1272,7 @@
if (ret)
goto out;
if (detach) {
- net_detach_sc(detach, NULL);
+ o2net_detach_sc(detach, NULL);
sc_put(detach);
detach = NULL;
}
@@ -1280,18 +1283,18 @@
/* record it as active initially to make sure we didn't miss
* any incoming data while we were setting it up */
- spin_lock_bh(&net_active_lock);
- net_sc_list_add(sc, &net_active_list);
- spin_unlock_bh(&net_active_lock);
+ spin_lock_bh(&o2net_active_lock);
+ o2net_sc_list_add(sc, &o2net_active_list);
+ spin_unlock_bh(&o2net_active_lock);
out:
sclog(sc, "attaching now node %p returned %d\n", node, ret);
return ret;
}
-static void net_state_change(struct sock *sk)
+static void o2net_state_change(struct sock *sk)
{
void (*state_change)(struct sock *sk);
- struct net_sock_container *sc;
+ struct o2net_sock_container *sc;
struct list_head *list = NULL;
write_lock(&sk->sk_callback_lock);
@@ -1313,28 +1316,29 @@
case TCP_SYN_RECV:
break;
case TCP_ESTABLISHED:
- list = &net_attach_list;
+ list = &o2net_attach_list;
break;
default:
- list = &net_detach_list;
+ list = &o2net_detach_list;
break;
}
/* if we've finished a connect or have seen an error we let
* the rx thread know so it can act accordingly on our behalf */
if (list) {
- spin_lock(&net_active_lock);
- net_sc_list_add(sc, list);
- spin_unlock(&net_active_lock);
+ spin_lock(&o2net_active_lock);
+ o2net_sc_list_add(sc, list);
+ spin_unlock(&o2net_active_lock);
}
out:
write_unlock(&sk->sk_callback_lock);
state_change(sk);
}
-static struct net_sock_container *sc_alloc(struct nm_node *node, int from_conn)
+static struct o2net_sock_container *sc_alloc(struct nm_node *node,
+ int from_conn)
{
- struct net_sock_container *sc, *ret = NULL;
+ struct o2net_sock_container *sc, *ret = NULL;
struct page *page = NULL;
page = alloc_page(GFP_NOFS);
@@ -1356,7 +1360,7 @@
ret = sc;
sc->sc_page = page;
- net_proc_add_sc(sc);
+ o2net_proc_add_sc(sc);
sc = NULL;
page = NULL;
@@ -1368,7 +1372,7 @@
return ret;
}
-static void net_finish_connect(struct nm_node *node)
+static void o2net_finish_connect(struct nm_node *node)
{
atomic_dec(&node->nd_pending_connects);
atomic_inc(&node->nd_sc_generation);
@@ -1376,11 +1380,11 @@
wake_up_all(&node->nd_sc_wq);
}
-static int net_start_connect(struct nm_node *node, u32 addr, u16 port)
+static int o2net_start_connect(struct nm_node *node, u32 addr, u16 port)
{
struct socket *sock = NULL;
struct sockaddr_in myaddr, remoteaddr;
- struct net_sock_container *sc = NULL;
+ struct o2net_sock_container *sc = NULL;
int ret;
sc = sc_alloc(node, 1);
@@ -1427,13 +1431,13 @@
sclog(sc, "->connect gave %d\n", ret);
out:
/* if ret == 0 then the callback has the responsibility of calling
- * net_finish_connect */
+ * o2net_finish_connect */
if (ret) {
- net_finish_connect(node);
+ o2net_finish_connect(node);
if (sc) {
/* stop detach from trying to finish again */
sc->sc_pending_connect = 0;
- net_detach_sc(sc, NULL);
+ o2net_detach_sc(sc, NULL);
}
if (sock)
sock_release(sock);
@@ -1443,7 +1447,7 @@
return ret;
}
-static void net_sock_drain(struct socket *sock)
+static void o2net_sock_drain(struct socket *sock)
{
int len;
mm_segment_t oldfs;
@@ -1475,10 +1479,10 @@
* the node to have an active socket. The rx thread might race with
* the connect() to accept() a socket that we'll happily use.
*/
-static int net_sc_from_node(struct nm_node *node,
- struct net_sock_container **sc_ret)
+static int o2net_sc_from_node(struct nm_node *node,
+ struct o2net_sock_container **sc_ret)
{
- struct net_sock_container *sc = NULL;
+ struct o2net_sock_container *sc = NULL;
int ret = 0, gen = 0, issue_connect = 0;
spin_lock_bh(&node->nd_lock);
@@ -1500,8 +1504,8 @@
if (issue_connect) {
/* either net_start_connect or the callbacks it registers
* have the responsibility of calling _finish_connect() */
- ret = net_start_connect(node, node->nd_ipv4_address,
- node->nd_ipv4_port);
+ ret = o2net_start_connect(node, node->nd_ipv4_address,
+ node->nd_ipv4_port);
if (ret)
goto out;
}
@@ -1554,13 +1558,13 @@
}
#endif /* MISSING_SOCK_CREATE_LITE */
-static void net_try_accept(struct socket *sock)
+static void o2net_try_accept(struct socket *sock)
{
int ret, slen;
struct sockaddr_in sin;
struct socket *new_sock = NULL;
struct nm_node *node = NULL;
- struct net_sock_container *sc = NULL;
+ struct o2net_sock_container *sc = NULL;
BUG_ON(sock == NULL);
ret = sock_create_lite(sock->sk->sk_family, sock->sk->sk_type,
@@ -1597,12 +1601,12 @@
sc->sc_sock = new_sock;
new_sock = NULL;
- ret = net_attach_sc(sc);
+ ret = o2net_attach_sc(sc);
out:
if (ret) {
if (new_sock) {
- net_sock_drain(new_sock);
+ o2net_sock_drain(new_sock);
sock_release(new_sock);
}
}
@@ -1613,7 +1617,7 @@
return;
}
-static struct socket *net_init_tcp_recv_sock(u16 port)
+static struct socket *o2net_init_tcp_recv_sock(u16 port)
{
struct sockaddr_in sin;
struct socket *sock;
Modified: trunk/fs/ocfs2/cluster/tcp.h
===================================================================
--- trunk/fs/ocfs2/cluster/tcp.h 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/tcp.h 2005-06-01 22:07:51 UTC (rev 2348)
@@ -43,34 +43,34 @@
*/
#include "nodemanager.h"
-enum net_system_error {
- NET_ERR_NONE = 0,
- NET_ERR_NO_HNDLR,
- NET_ERR_OVERFLOW,
- NET_ERR_DIED,
- NET_ERR_MAX
+enum o2net_system_error {
+ O2NET_ERR_NONE = 0,
+ O2NET_ERR_NO_HNDLR,
+ O2NET_ERR_OVERFLOW,
+ O2NET_ERR_DIED,
+ O2NET_ERR_MAX
};
-static int net_sys_err_translations[NET_ERR_MAX] =
- {[NET_ERR_NONE] = 0,
- [NET_ERR_NO_HNDLR] = -ENOPROTOOPT,
- [NET_ERR_OVERFLOW] = -EOVERFLOW,
- [NET_ERR_DIED] = -EHOSTDOWN,};
+static int o2net_sys_err_translations[O2NET_ERR_MAX] =
+ {[O2NET_ERR_NONE] = 0,
+ [O2NET_ERR_NO_HNDLR] = -ENOPROTOOPT,
+ [O2NET_ERR_OVERFLOW] = -EOVERFLOW,
+ [O2NET_ERR_DIED] = -EHOSTDOWN,};
-static inline int net_sys_err_to_errno(enum net_system_error err)
+static inline int o2net_sys_err_to_errno(enum o2net_system_error err)
{
int trans;
- BUG_ON(err >= NET_ERR_MAX);
- trans = net_sys_err_translations[err];
+ BUG_ON(err >= O2NET_ERR_MAX);
+ trans = o2net_sys_err_translations[err];
/* Just in case we mess up the translation table above */
- BUG_ON(err != NET_ERR_NONE && trans == 0);
+ BUG_ON(err != O2NET_ERR_NONE && trans == 0);
return trans;
}
-#define NET_MSG_MAGIC ((u16)0xfa55)
-#define NET_MSG_STATUS_MAGIC ((u16)0xfa56)
-typedef struct _net_msg
+#define O2NET_MSG_MAGIC ((u16)0xfa55)
+#define O2NET_MSG_STATUS_MAGIC ((u16)0xfa56)
+typedef struct _o2net_msg
{
__u16 magic;
__u16 data_len;
@@ -81,9 +81,9 @@
__u32 key;
__u32 msg_num;
__u8 buf[0];
-} net_msg;
+} o2net_msg;
-static inline void net_msg_to_net(net_msg *m)
+static inline void o2net_msg_to_net(o2net_msg *m)
{
m->magic = htons(m->magic);
m->data_len = htons(m->data_len);
@@ -93,7 +93,8 @@
m->key = htonl(m->key);
m->msg_num = htonl(m->msg_num);
}
-static inline void net_msg_to_host(net_msg *m)
+
+static inline void o2net_msg_to_host(o2net_msg *m)
{
m->magic = ntohs(m->magic);
m->data_len = ntohs(m->data_len);
@@ -104,16 +105,16 @@
m->msg_num = ntohl(m->msg_num);
}
-typedef int (net_msg_handler_func)(net_msg *msg, u32 len, void *data);
+typedef int (o2net_msg_handler_func)(o2net_msg *msg, u32 len, void *data);
-#define NET_MAX_PAYLOAD_BYTES (4096 - sizeof(net_msg))
+#define O2NET_MAX_PAYLOAD_BYTES (4096 - sizeof(o2net_msg))
/* RESERVED */
-#define NET_ALREADY_CONNECTED (0xfff0)
-#define NET_UNKNOWN_HOST (0xfff1)
+#define O2NET_ALREADY_CONNECTED (0xfff0)
+#define O2NET_UNKNOWN_HOST (0xfff1)
/* TODO: figure this out.... */
-static inline int net_link_down(int err, struct socket *sock)
+static inline int o2net_link_down(int err, struct socket *sock)
{
if (sock) {
if (sock->sk->sk_state != TCP_ESTABLISHED &&
@@ -139,34 +140,35 @@
}
enum {
- NET_DRIVER_UNINITED,
- NET_DRIVER_READY,
+ O2NET_DRIVER_UNINITED,
+ O2NET_DRIVER_READY,
};
-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);
+int o2net_init_tcp_sock(struct inode *inode);
+int o2net_send_message(u32 msg_type, u32 key, void *data, u32 len,
+ u8 target_node, int *status);
+int o2net_send_message_iov(u32 msg_type, u32 key, struct iovec *iov,
+ size_t iovlen, u8 target_node, int *status);
+int o2net_broadcast_message(u32 msg_type, u32 key, void *data, u32 len,
+ struct inode *group);
-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 o2net_register_handler(u32 msg_type, u32 key, u32 max_len,
+ o2net_msg_handler_func *func, void *data,
+ struct list_head *unreg_list);
+void o2net_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);
-void net_stop_rx_thread(struct nm_node *node);
-struct net_sock_container;
-void net_detach_sc(struct net_sock_container *sc, struct nm_node *node);
+int o2net_register_hb_callbacks(void);
+void o2net_unregister_hb_callbacks(void);
+int o2net_start_rx_thread(struct nm_node *node);
+void o2net_stop_rx_thread(struct nm_node *node);
+struct o2net_sock_container;
+void o2net_detach_sc(struct o2net_sock_container *sc, struct nm_node *node);
-int net_proc_init(struct proc_dir_entry *parent);
-void net_proc_exit(struct proc_dir_entry *parent);
+int o2net_proc_init(struct proc_dir_entry *parent);
+void o2net_proc_exit(struct proc_dir_entry *parent);
-struct net_send_tracking;
-void net_proc_add_nst(struct net_send_tracking *nst);
-void net_proc_del_nst(struct net_send_tracking *nst);
+struct o2net_send_tracking;
+void o2net_proc_add_nst(struct o2net_send_tracking *nst);
+void o2net_proc_del_nst(struct o2net_send_tracking *nst);
#endif /* CLUSTER_TCP_H */
Modified: trunk/fs/ocfs2/cluster/tcp_internal.h
===================================================================
--- trunk/fs/ocfs2/cluster/tcp_internal.h 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/cluster/tcp_internal.h 2005-06-01 22:07:51 UTC (rev 2348)
@@ -23,7 +23,7 @@
#ifndef CLUSTER_TCP_INTERNAL_H
#define CLUSTER_TCP_INTERNAL_H
-struct net_sock_container {
+struct o2net_sock_container {
/* sockets themselves don't seem to have a nice way to refcount them
* above sock_release. one could use iget/iput, but that seems
* to interact poorly with sock_release() itself calling iput. */
@@ -48,19 +48,19 @@
struct list_head sc_net_proc_item;
};
-struct net_msg_handler {
+struct o2net_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;
+ o2net_msg_handler_func *nh_func;
+ o2net_msg_handler_func *nh_func_data;
struct kref nh_kref;
struct list_head nh_unregister_item;
};
-struct net_status_wait {
- enum net_system_error ns_sys_status;
+struct o2net_status_wait {
+ enum o2net_system_error ns_sys_status;
s32 ns_status;
int ns_id;
wait_queue_head_t ns_wq;
@@ -68,11 +68,11 @@
};
/* just for state dumps */
-struct net_send_tracking {
+struct o2net_send_tracking {
struct list_head st_net_proc_item;
struct task_struct *st_task;
struct nm_node *st_node;
- struct net_sock_container *st_sc;
+ struct o2net_sock_container *st_sc;
u32 st_msg_type;
u32 st_msg_key;
struct timeval st_sock_time;
@@ -80,7 +80,7 @@
struct timeval st_status_time;
};
-void net_proc_add_sc(struct net_sock_container *sc);
-void net_proc_del_sc(struct net_sock_container *sc);
+void o2net_proc_add_sc(struct o2net_sock_container *sc);
+void o2net_proc_del_sc(struct o2net_sock_container *sc);
#endif /* CLUSTER_TCP_INTERNAL_H */
Modified: trunk/fs/ocfs2/dlm/dlmast.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmast.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmast.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -249,7 +249,7 @@
-int dlm_proxy_ast_handler(net_msg *msg, u32 len, void *data)
+int dlm_proxy_ast_handler(o2net_msg *msg, u32 len, void *data)
{
int ret;
unsigned int locklen;
@@ -436,8 +436,8 @@
}
dlm_proxy_ast_to_net(&past);
- ret = net_send_message_iov(DLM_PROXY_AST_MSG, dlm->key, iov, iovlen,
- lock->ml.node, &status);
+ ret = o2net_send_message_iov(DLM_PROXY_AST_MSG, dlm->key, iov, iovlen,
+ lock->ml.node, &status);
if (ret < 0)
mlog_errno(ret);
else {
Modified: trunk/fs/ocfs2/dlm/dlmcommon.h
===================================================================
--- trunk/fs/ocfs2/dlm/dlmcommon.h 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmcommon.h 2005-06-01 22:07:51 UTC (rev 2348)
@@ -792,11 +792,11 @@
void dlm_lock_detach_lockres(dlm_lock *lock);
void dlm_lock_attach_lockres(dlm_lock *lock, dlm_lock_resource *res);
-int dlm_create_lock_handler(net_msg *msg, u32 len, void *data);
-int dlm_convert_lock_handler(net_msg *msg, u32 len, void *data);
-int dlm_proxy_ast_handler(net_msg *msg, u32 len, void *data);
+int dlm_create_lock_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_convert_lock_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_proxy_ast_handler(o2net_msg *msg, u32 len, void *data);
-int dlm_unlock_lock_handler(net_msg *msg, u32 len, void *data);
+int dlm_unlock_lock_handler(o2net_msg *msg, u32 len, void *data);
void dlm_shuffle_lists(dlm_ctxt *dlm, dlm_lock_resource *res);
int dlm_launch_thread(dlm_ctxt *dlm);
@@ -874,15 +874,15 @@
void dlm_lockres_release_ast(dlm_lock_resource *res);
void __dlm_lockres_reserve_ast(dlm_lock_resource *res);
-int dlm_master_request_handler(net_msg *msg, u32 len, void *data);
-int dlm_assert_master_handler(net_msg *msg, u32 len, void *data);
-int dlm_migrate_request_handler(net_msg *msg, u32 len, void *data);
-int dlm_mig_lockres_handler(net_msg *msg, u32 len, void *data);
-int dlm_master_requery_handler(net_msg *msg, u32 len, void *data);
-int dlm_request_all_locks_handler(net_msg *msg, u32 len, void *data);
-int dlm_reco_data_done_handler(net_msg *msg, u32 len, void *data);
-int dlm_begin_reco_handler(net_msg *msg, u32 len, void *data);
-int dlm_finalize_reco_handler(net_msg *msg, u32 len, void *data);
+int dlm_master_request_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_assert_master_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_migrate_request_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_mig_lockres_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_master_requery_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_request_all_locks_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_reco_data_done_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_begin_reco_handler(o2net_msg *msg, u32 len, void *data);
+int dlm_finalize_reco_handler(o2net_msg *msg, u32 len, void *data);
int dlm_dispatch_assert_master(dlm_ctxt *dlm, dlm_lock_resource *res,
int ignore_higher, u8 request_from,
@@ -1006,7 +1006,7 @@
dlm_status ret;
if (err == -ENOMEM)
ret = DLM_SYSERR;
- else if (err == -ETIMEDOUT || net_link_down(err, NULL))
+ else if (err == -ETIMEDOUT || o2net_link_down(err, NULL))
ret = DLM_NOLOCKMGR;
else if (err == -EINVAL)
ret = DLM_BADPARAM;
Modified: trunk/fs/ocfs2/dlm/dlmconvert.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmconvert.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmconvert.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -350,8 +350,8 @@
}
dlm_convert_lock_to_net(&convert);
- tmpret = net_send_message_iov(DLM_CONVERT_LOCK_MSG, dlm->key,
- iov, iovlen, res->owner, &status);
+ tmpret = o2net_send_message_iov(DLM_CONVERT_LOCK_MSG, dlm->key,
+ iov, iovlen, res->owner, &status);
if (tmpret >= 0) {
// successfully sent and received
ret = status; // this is already a dlm_status
@@ -382,7 +382,7 @@
* returns: DLM_NORMAL, DLM_IVLOCKID, DLM_BADARGS,
* status from __dlmconvert_master
*/
-int dlm_convert_lock_handler(net_msg *msg, u32 len, void *data)
+int dlm_convert_lock_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_convert_lock *cnv = (dlm_convert_lock *)msg->buf;
Modified: trunk/fs/ocfs2/dlm/dlmdomain.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmdomain.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmdomain.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -65,10 +65,10 @@
LIST_HEAD(dlm_domains);
static DECLARE_WAIT_QUEUE_HEAD(dlm_domain_events);
-static int dlm_query_join_handler(net_msg *msg, u32 len, void *data);
-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 int dlm_query_join_handler(o2net_msg *msg, u32 len, void *data);
+static int dlm_assert_joined_handler(o2net_msg *msg, u32 len, void *data);
+static int dlm_cancel_join_handler(o2net_msg *msg, u32 len, void *data);
+static int dlm_exit_domain_handler(o2net_msg *msg, u32 len, void *data);
static void dlm_unregister_domain_handlers(dlm_ctxt *dlm);
@@ -397,7 +397,7 @@
}
}
-static int dlm_exit_domain_handler(net_msg *msg, u32 len, void *data)
+static int dlm_exit_domain_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
unsigned int node;
@@ -438,11 +438,11 @@
dlm_exit_domin_to_net(&leave_msg);
- status = net_send_message(DLM_EXIT_DOMAIN_MSG, dlm->key,
- &leave_msg, sizeof(leave_msg), node,
- NULL);
+ status = o2net_send_message(DLM_EXIT_DOMAIN_MSG, dlm->key,
+ &leave_msg, sizeof(leave_msg), node,
+ NULL);
- mlog(0, "status return %d from net_send_message\n", status);
+ mlog(0, "status return %d from o2net_send_message\n", status);
return status;
}
@@ -467,10 +467,10 @@
/* Drop the dlm spinlock. This is safe wrt the domain_map.
* -nodes cannot be added now as the
- * query_join_handlers knows to respond with OK_NO_MAP
+ * query_join_handlers knows to respond with OK_NO_MAP
* -we catch the right network errors if a node is
- * removed from the map while we're sending him the
- * exit message. */
+ * removed from the map while we're sending him the
+ * exit message. */
spin_unlock(&dlm->spinlock);
clear_node = 1;
@@ -532,7 +532,7 @@
}
EXPORT_SYMBOL_GPL(dlm_unregister_domain);
-static int dlm_query_join_handler(net_msg *msg, u32 len, void *data)
+static int dlm_query_join_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_query_join_request *query;
enum dlm_query_join_response response;
@@ -580,7 +580,7 @@
return response;
}
-static int dlm_assert_joined_handler(net_msg *msg, u32 len, void *data)
+static int dlm_assert_joined_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_assert_joined *assert;
dlm_ctxt *dlm = NULL;
@@ -613,7 +613,7 @@
return 0;
}
-static int dlm_cancel_join_handler(net_msg *msg, u32 len, void *data)
+static int dlm_cancel_join_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_cancel_join *cancel;
dlm_ctxt *dlm = NULL;
@@ -655,9 +655,9 @@
dlm_cancel_join_to_net(&cancel_msg);
- status = net_send_message(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY,
- &cancel_msg, sizeof(cancel_msg), node,
- NULL);
+ status = o2net_send_message(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY,
+ &cancel_msg, sizeof(cancel_msg), node,
+ NULL);
if (status < 0) {
mlog_errno(status);
goto bail;
@@ -716,21 +716,21 @@
dlm_query_join_request_to_net(&join_msg);
- status = net_send_message(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY, &join_msg,
- sizeof(join_msg), node, &retval);
+ status = o2net_send_message(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY, &join_msg,
+ sizeof(join_msg), node, &retval);
if (status < 0 && status != -ENOPROTOOPT && status != -ENOTCONN) {
mlog_errno(status);
goto bail;
}
/* -ENOPROTOOPT from the net code means the other side isn't
- listening for our message type -- that's fine, it means
- his dlm isn't up, so we can consider him a 'yes' but not
- joined into the domain.
+ listening for our message type -- that's fine, it means
+ his dlm isn't up, so we can consider him a 'yes' but not
+ joined into the domain.
-ENOTCONN is treated similarly -- it's returned from the
- core kernel net code however and indicates that they don't
- even have their cluster networking module loaded (bad
- user!) */
+ core kernel net code however and indicates that they don't
+ even have their cluster networking module loaded (bad
+ user!) */
if (status == -ENOPROTOOPT || status == -ENOTCONN) {
status = 0;
*response = JOIN_OK_NO_MAP;
@@ -766,8 +766,9 @@
dlm_assert_joined_to_net(&assert_msg);
- status = net_send_message(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY,
- &assert_msg, sizeof(assert_msg), node, NULL);
+ status = o2net_send_message(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY,
+ &assert_msg, sizeof(assert_msg), node,
+ NULL);
if (status < 0)
mlog_errno(status);
@@ -932,7 +933,7 @@
static void dlm_unregister_domain_handlers(dlm_ctxt *dlm)
{
- net_unregister_handler_list(&dlm->dlm_domain_handlers);
+ o2net_unregister_handler_list(&dlm->dlm_domain_handlers);
}
static int dlm_register_domain_handlers(dlm_ctxt *dlm)
@@ -953,101 +954,101 @@
if (status)
goto bail;
- status = net_register_handler(DLM_MASTER_REQUEST_MSG, dlm->key,
- sizeof(dlm_master_request),
- dlm_master_request_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_MASTER_REQUEST_MSG, dlm->key,
+ sizeof(dlm_master_request),
+ dlm_master_request_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_ASSERT_MASTER_MSG, dlm->key,
- sizeof(dlm_assert_master),
- dlm_assert_master_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_ASSERT_MASTER_MSG, dlm->key,
+ sizeof(dlm_assert_master),
+ dlm_assert_master_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_CREATE_LOCK_MSG, dlm->key,
- sizeof(dlm_create_lock),
- dlm_create_lock_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_CREATE_LOCK_MSG, dlm->key,
+ sizeof(dlm_create_lock),
+ dlm_create_lock_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_CONVERT_LOCK_MSG, dlm->key,
- DLM_CONVERT_LOCK_MAX_LEN,
- dlm_convert_lock_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_CONVERT_LOCK_MSG, dlm->key,
+ DLM_CONVERT_LOCK_MAX_LEN,
+ dlm_convert_lock_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_UNLOCK_LOCK_MSG, dlm->key,
- DLM_UNLOCK_LOCK_MAX_LEN,
- dlm_unlock_lock_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_UNLOCK_LOCK_MSG, dlm->key,
+ DLM_UNLOCK_LOCK_MAX_LEN,
+ dlm_unlock_lock_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_PROXY_AST_MSG, dlm->key,
- DLM_PROXY_AST_MAX_LEN,
- dlm_proxy_ast_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_PROXY_AST_MSG, dlm->key,
+ DLM_PROXY_AST_MAX_LEN,
+ dlm_proxy_ast_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_EXIT_DOMAIN_MSG, dlm->key,
- sizeof(dlm_exit_domain),
- dlm_exit_domain_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_EXIT_DOMAIN_MSG, dlm->key,
+ sizeof(dlm_exit_domain),
+ dlm_exit_domain_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_MIGRATE_REQUEST_MSG, dlm->key,
- sizeof(dlm_migrate_request),
- dlm_migrate_request_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_MIGRATE_REQUEST_MSG, dlm->key,
+ sizeof(dlm_migrate_request),
+ dlm_migrate_request_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_MIG_LOCKRES_MSG, dlm->key,
- DLM_MIG_LOCKRES_MAX_LEN,
- dlm_mig_lockres_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_MIG_LOCKRES_MSG, dlm->key,
+ DLM_MIG_LOCKRES_MAX_LEN,
+ dlm_mig_lockres_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_MASTER_REQUERY_MSG, dlm->key,
- sizeof(dlm_master_requery),
- dlm_master_requery_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_MASTER_REQUERY_MSG, dlm->key,
+ sizeof(dlm_master_requery),
+ dlm_master_requery_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_LOCK_REQUEST_MSG, dlm->key,
- sizeof(dlm_lock_request),
- dlm_request_all_locks_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_LOCK_REQUEST_MSG, dlm->key,
+ sizeof(dlm_lock_request),
+ dlm_request_all_locks_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_RECO_DATA_DONE_MSG, dlm->key,
- sizeof(dlm_reco_data_done),
- dlm_reco_data_done_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_RECO_DATA_DONE_MSG, dlm->key,
+ sizeof(dlm_reco_data_done),
+ dlm_reco_data_done_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_BEGIN_RECO_MSG, dlm->key,
- sizeof(dlm_begin_reco),
- dlm_begin_reco_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_BEGIN_RECO_MSG, dlm->key,
+ sizeof(dlm_begin_reco),
+ dlm_begin_reco_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_FINALIZE_RECO_MSG, dlm->key,
- sizeof(dlm_finalize_reco),
- dlm_finalize_reco_handler,
- dlm, &dlm->dlm_domain_handlers);
+ status = o2net_register_handler(DLM_FINALIZE_RECO_MSG, dlm->key,
+ sizeof(dlm_finalize_reco),
+ dlm_finalize_reco_handler,
+ dlm, &dlm->dlm_domain_handlers);
if (status)
goto bail;
@@ -1300,31 +1301,31 @@
static void dlm_unregister_net_handlers(void)
{
- net_unregister_handler_list(&dlm_join_handlers);
+ o2net_unregister_handler_list(&dlm_join_handlers);
}
static int dlm_register_net_handlers(void)
{
int status = 0;
- status = net_register_handler(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY,
- sizeof(dlm_query_join_request),
- dlm_query_join_handler,
- NULL, &dlm_join_handlers);
+ status = o2net_register_handler(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY,
+ sizeof(dlm_query_join_request),
+ dlm_query_join_handler,
+ NULL, &dlm_join_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY,
- sizeof(dlm_assert_joined),
- dlm_assert_joined_handler,
- NULL, &dlm_join_handlers);
+ status = o2net_register_handler(DLM_ASSERT_JOINED_MSG, DLM_MOD_KEY,
+ sizeof(dlm_assert_joined),
+ dlm_assert_joined_handler,
+ NULL, &dlm_join_handlers);
if (status)
goto bail;
- status = net_register_handler(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY,
- sizeof(dlm_cancel_join),
- dlm_cancel_join_handler,
- NULL, &dlm_join_handlers);
+ status = o2net_register_handler(DLM_CANCEL_JOIN_MSG, DLM_MOD_KEY,
+ sizeof(dlm_cancel_join),
+ dlm_cancel_join_handler,
+ NULL, &dlm_join_handlers);
bail:
if (status < 0)
Modified: trunk/fs/ocfs2/dlm/dlmlock.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmlock.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmlock.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -244,8 +244,8 @@
strncpy(create.name, res->lockname.name, create.namelen);
dlm_create_lock_to_net(&create);
- tmpret = net_send_message(DLM_CREATE_LOCK_MSG, dlm->key, &create,
- sizeof(create), res->owner, &status);
+ tmpret = o2net_send_message(DLM_CREATE_LOCK_MSG, dlm->key, &create,
+ sizeof(create), res->owner, &status);
if (tmpret >= 0) {
// successfully sent and received
ret = status; // this is already a dlm_status
@@ -372,7 +372,7 @@
* held on exit: none
* returns: DLM_NORMAL, DLM_SYSERR, DLM_IVLOCKID, DLM_NOTQUEUED
*/
-int dlm_create_lock_handler(net_msg *msg, u32 len, void *data)
+int dlm_create_lock_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_create_lock *create = (dlm_create_lock *)msg->buf;
Modified: trunk/fs/ocfs2/dlm/dlmmaster.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmmaster.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmmaster.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -863,8 +863,8 @@
}
dlm_master_request_to_net(&request);
- ret = net_send_message(DLM_MASTER_REQUEST_MSG, dlm->key, &request,
- sizeof(request), to, &response);
+ ret = o2net_send_message(DLM_MASTER_REQUEST_MSG, dlm->key, &request,
+ sizeof(request), to, &response);
if (ret < 0) {
mlog_errno(ret);
goto out;
@@ -914,7 +914,7 @@
*
* if possible, TRIM THIS DOWN!!!
*/
-int dlm_master_request_handler(net_msg *msg, u32 len, void *data)
+int dlm_master_request_handler(o2net_msg *msg, u32 len, void *data)
{
u8 response = DLM_MASTER_RESP_MAYBE;
dlm_ctxt *dlm = data;
@@ -1147,8 +1147,8 @@
assert.flags = flags;
dlm_assert_master_to_net(&assert);
- tmpret = net_send_message(DLM_ASSERT_MASTER_MSG, dlm->key,
- &assert, sizeof(assert), to, &r);
+ tmpret = o2net_send_message(DLM_ASSERT_MASTER_MSG, dlm->key,
+ &assert, sizeof(assert), to, &r);
if (tmpret < 0) {
// TODO
// mlog(0, "assert_master returned %d!\n", tmpret);
@@ -1175,7 +1175,7 @@
*
* if possible, TRIM THIS DOWN!!!
*/
-int dlm_assert_master_handler(net_msg *msg, u32 len, void *data)
+int dlm_assert_master_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_master_list_entry *mle = NULL;
@@ -1798,8 +1798,9 @@
nodenum == new_master)
continue;
- ret = net_send_message(DLM_MIGRATE_REQUEST_MSG, dlm->key,
- &migrate, sizeof(migrate), nodenum, &status);
+ ret = o2net_send_message(DLM_MIGRATE_REQUEST_MSG, dlm->key,
+ &migrate, sizeof(migrate), nodenum,
+ &status);
if (ret < 0)
mlog_errno(ret);
else if (status < 0) {
@@ -1824,7 +1825,7 @@
* we will have no mle in the list to start with. now we can add an mle for
* the migration and this should be the only one found for those scanning the
* list. */
-int dlm_migrate_request_handler(net_msg *msg, u32 len, void *data)
+int dlm_migrate_request_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_lock_resource *res = NULL;
Modified: trunk/fs/ocfs2/dlm/dlmrecovery.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmrecovery.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmrecovery.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -565,9 +565,8 @@
// send message
ret = DLM_NOLOCKMGR;
dlm_lock_request_to_net(&lr);
- ret = net_send_message(DLM_LOCK_REQUEST_MSG, dlm->key,
- &lr, sizeof(lr),
- request_from, NULL);
+ ret = o2net_send_message(DLM_LOCK_REQUEST_MSG, dlm->key,
+ &lr, sizeof(lr), request_from, NULL);
if (ret < 0)
mlog_errno(ret);
@@ -577,7 +576,7 @@
}
-int dlm_request_all_locks_handler(net_msg *msg, u32 len, void *data)
+int dlm_request_all_locks_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_lock_request *lr = (dlm_lock_request *)msg->buf;
@@ -688,15 +687,15 @@
done_msg->dead_node = dead_node;
dlm_reco_data_done_to_net(done_msg);
- ret = net_send_message(DLM_RECO_DATA_DONE_MSG, dlm->key, &done_msg,
- sizeof(done_msg), send_to, &tmpret);
+ ret = o2net_send_message(DLM_RECO_DATA_DONE_MSG, dlm->key, &done_msg,
+ sizeof(done_msg), send_to, &tmpret);
if (ret >= 0)
ret = tmpret;
return ret;
}
-int dlm_reco_data_done_handler(net_msg *msg, u32 len, void *data)
+int dlm_reco_data_done_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_reco_data_done *done = (dlm_reco_data_done *)msg->buf;
@@ -823,8 +822,8 @@
dlm_migratable_lockres_to_net(mres);
/* send it */
- ret = net_send_message(DLM_MIG_LOCKRES_MSG, dlm->key, mres,
- sz, send_to, &status);
+ ret = o2net_send_message(DLM_MIG_LOCKRES_MSG, dlm->key, mres,
+ sz, send_to, &status);
if (ret < 0) {
mlog_errno(ret);
} else {
@@ -972,7 +971,7 @@
* do we spin? returning an error only delays the problem really
*/
-int dlm_mig_lockres_handler(net_msg *msg, u32 len, void *data)
+int dlm_mig_lockres_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_migratable_lockres *mres = (dlm_migratable_lockres *)msg->buf;
@@ -1228,8 +1227,8 @@
strncpy(req.name, res->lockname.name, res->lockname.len);
dlm_master_requery_to_net(&req);
- ret = net_send_message(DLM_MASTER_REQUERY_MSG, dlm->key,
- &req, sizeof(req), nodenum, &status);
+ ret = o2net_send_message(DLM_MASTER_REQUERY_MSG, dlm->key,
+ &req, sizeof(req), nodenum, &status);
if (ret < 0)
mlog_errno(ret);
else {
@@ -1247,7 +1246,7 @@
/* this function cannot error, so unless the sending
* or receiving of the message failed, the owner can
* be trusted */
-int dlm_master_requery_handler(net_msg *msg, u32 len, void *data)
+int dlm_master_requery_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_master_requery *req = (dlm_master_requery *)msg->buf;
@@ -1735,9 +1734,8 @@
ret = -EINVAL;
mlog(0, "attempting to send begin reco msg to %d\n",
nodenum);
- ret = net_send_message(DLM_BEGIN_RECO_MSG, dlm->key,
- &br, sizeof(br),
- nodenum, &status);
+ ret = o2net_send_message(DLM_BEGIN_RECO_MSG, dlm->key,
+ &br, sizeof(br), nodenum, &status);
if (ret >= 0)
ret = status;
if (ret < 0) {
@@ -1749,7 +1747,7 @@
return ret;
}
-int dlm_begin_reco_handler(net_msg *msg, u32 len, void *data)
+int dlm_begin_reco_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_begin_reco *br = (dlm_begin_reco *)msg->buf;
@@ -1802,9 +1800,8 @@
while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {
if (nodenum == dlm->node_num)
continue;
- ret = net_send_message(DLM_FINALIZE_RECO_MSG, dlm->key,
- &fr, sizeof(fr),
- nodenum, &status);
+ ret = o2net_send_message(DLM_FINALIZE_RECO_MSG, dlm->key,
+ &fr, sizeof(fr), nodenum, &status);
if (ret >= 0)
ret = status;
if (ret < 0) {
@@ -1816,7 +1813,7 @@
return ret;
}
-int dlm_finalize_reco_handler(net_msg *msg, u32 len, void *data)
+int dlm_finalize_reco_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_finalize_reco *fr = (dlm_finalize_reco *)msg->buf;
Modified: trunk/fs/ocfs2/dlm/dlmunlock.c
===================================================================
--- trunk/fs/ocfs2/dlm/dlmunlock.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/dlm/dlmunlock.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -273,8 +273,8 @@
}
dlm_unlock_lock_to_net(&unlock);
- tmpret = net_send_message_iov(DLM_UNLOCK_LOCK_MSG, dlm->key,
- iov, iovlen, owner, &status);
+ tmpret = o2net_send_message_iov(DLM_UNLOCK_LOCK_MSG, dlm->key,
+ iov, iovlen, owner, &status);
if (tmpret >= 0) {
// successfully sent and received
if (status == DLM_CANCELGRANT)
@@ -302,7 +302,7 @@
* returns: DLM_NORMAL, DLM_BADARGS, DLM_IVLOCKID,
* return value from dlmunlock_master
*/
-int dlm_unlock_lock_handler(net_msg *msg, u32 len, void *data)
+int dlm_unlock_lock_handler(o2net_msg *msg, u32 len, void *data)
{
dlm_ctxt *dlm = data;
dlm_unlock_lock *unlock = (dlm_unlock_lock *)msg->buf;
Modified: trunk/fs/ocfs2/vote.c
===================================================================
--- trunk/fs/ocfs2/vote.c 2005-06-01 17:56:07 UTC (rev 2347)
+++ trunk/fs/ocfs2/vote.c 2005-06-01 22:07:51 UTC (rev 2348)
@@ -351,12 +351,12 @@
response.r_response = htonl(vote_response);
response.r_orphaned_slot = htonl(orphaned_slot);
- net_status = net_send_message(OCFS2_MESSAGE_TYPE_RESPONSE,
- osb->net_key,
- &response,
- sizeof(ocfs2_response_msg),
- node_num,
- NULL);
+ net_status = o2net_send_message(OCFS2_MESSAGE_TYPE_RESPONSE,
+ osb->net_key,
+ &response,
+ sizeof(ocfs2_response_msg),
+ node_num,
+ NULL);
/* We still want to error print for ENOPROTOOPT here. The
* sending node shouldn't have unregistered his net handler
* without sending an unmount vote 1st */
@@ -577,12 +577,12 @@
ocfs_node_map_set_bit(osb, &w->n_node_map, i);
remote_err = 0;
- status = net_send_message(OCFS2_MESSAGE_TYPE_VOTE,
- osb->net_key,
- request,
- sizeof(*request),
- i,
- &remote_err);
+ status = o2net_send_message(OCFS2_MESSAGE_TYPE_VOTE,
+ osb->net_key,
+ request,
+ sizeof(*request),
+ i,
+ &remote_err);
if (status == -ETIMEDOUT) {
mlog(0, "remote node %d timed out!\n", i);
status = -EAGAIN;
@@ -856,7 +856,7 @@
return ret;
}
-static int ocfs2_handle_response_message(net_msg *msg,
+static int ocfs2_handle_response_message(o2net_msg *msg,
u32 len,
void *data)
{
@@ -910,9 +910,9 @@
return 0;
}
-static int ocfs2_handle_vote_message(net_msg *msg,
- u32 len,
- void *data)
+static int ocfs2_handle_vote_message(o2net_msg *msg,
+ u32 len,
+ void *data)
{
int status;
ocfs_super *osb = data;
@@ -955,7 +955,7 @@
if (!osb->net_key)
return;
- net_unregister_handler_list(&osb->osb_net_handlers);
+ o2net_unregister_handler_list(&osb->osb_net_handlers);
if (!list_empty(&osb->net_response_list))
mlog(ML_ERROR, "net response list not empty!\n");
@@ -973,21 +973,21 @@
spin_lock_init(&osb->net_response_lock);
INIT_LIST_HEAD(&osb->net_response_list);
- status = net_register_handler(OCFS2_MESSAGE_TYPE_RESPONSE,
- osb->net_key,
- sizeof(ocfs2_response_msg),
- ocfs2_handle_response_message,
- osb, &osb->osb_net_handlers);
+ status = o2net_register_handler(OCFS2_MESSAGE_TYPE_RESPONSE,
+ osb->net_key,
+ sizeof(ocfs2_response_msg),
+ ocfs2_handle_response_message,
+ osb, &osb->osb_net_handlers);
if (status) {
mlog_errno(status);
goto bail;
}
- status = net_register_handler(OCFS2_MESSAGE_TYPE_VOTE,
- osb->net_key,
- sizeof(ocfs2_vote_msg),
- ocfs2_handle_vote_message,
- osb, &osb->osb_net_handlers);
+ status = o2net_register_handler(OCFS2_MESSAGE_TYPE_VOTE,
+ osb->net_key,
+ sizeof(ocfs2_vote_msg),
+ ocfs2_handle_vote_message,
+ osb, &osb->osb_net_handlers);
if (status) {
mlog_errno(status);
goto bail;
More information about the Ocfs2-commits
mailing list