Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2 (741441ab) · Commits · e / devices / android_kernel_fairphone_FP4

Documentation/filesystems/ocfs2.txt

+3 −0

Original line number	Diff line number	Diff line
		@@ -54,3 +54,6 @@ errors=panic Panic and halt the machine if an error occurs.
		intr (*) Allow signals to interrupt cluster operations.
		nointr Do not allow signals to interrupt cluster
		operations.
		atime_quantum=60(*) OCFS2 will not update atime unless this number
		of seconds has passed since the last update.
		Set to zero to always update atime.

fs/ocfs2/cluster/nodemanager.c

+180 −12

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@
		/* for now we operate under the assertion that there can be only one
		* cluster active at a time. Changing this will require trickling
		* cluster references throughout where nodes are looked up */
		static struct o2nm_cluster *o2nm_single_cluster = NULL;
		struct o2nm_cluster *o2nm_single_cluster = NULL;

		#define OCFS2_MAX_HB_CTL_PATH 256
		static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
		@@ -97,17 +97,6 @@ const char *o2nm_get_hb_ctl_path(void)
		}
		EXPORT_SYMBOL_GPL(o2nm_get_hb_ctl_path);

		struct o2nm_cluster {
		struct config_group cl_group;
		unsigned cl_has_local:1;
		u8 cl_local_node;
		rwlock_t cl_nodes_lock;
		struct o2nm_node *cl_nodes[O2NM_MAX_NODES];
		struct rb_root cl_node_ip_tree;
		/* this bitmap is part of a hack for disk bitmap.. will go eventually. - zab */
		unsigned long cl_nodes_bitmap[BITS_TO_LONGS(O2NM_MAX_NODES)];
		};

		struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
		{
		struct o2nm_node *node = NULL;
		@@ -543,6 +532,179 @@ static struct o2nm_node_group to_o2nm_node_group(struct config_group group)
		}
		#endif

		struct o2nm_cluster_attribute {
		struct configfs_attribute attr;
		ssize_t (show)(struct o2nm_cluster , char *);
		ssize_t (store)(struct o2nm_cluster , const char *, size_t);
		};

		static ssize_t o2nm_cluster_attr_write(const char *page, ssize_t count,
		unsigned int *val)
		{
		unsigned long tmp;
		char p = (char )page;

		tmp = simple_strtoul(p, &p, 0);
		if (!p \|\| (p && (p != '\n')))
		return -EINVAL;

		if (tmp == 0)
		return -EINVAL;
		if (tmp >= (u32)-1)
		return -ERANGE;

		*val = tmp;

		return count;
		}

		static ssize_t o2nm_cluster_attr_idle_timeout_ms_read(
		struct o2nm_cluster cluster, char page)
		{
		return sprintf(page, "%u\n", cluster->cl_idle_timeout_ms);
		}

		static ssize_t o2nm_cluster_attr_idle_timeout_ms_write(
		struct o2nm_cluster cluster, const char page, size_t count)
		{
		ssize_t ret;
		unsigned int val;

		ret = o2nm_cluster_attr_write(page, count, &val);

		if (ret > 0) {
		if (cluster->cl_idle_timeout_ms != val
		&& o2net_num_connected_peers()) {
		mlog(ML_NOTICE,
		"o2net: cannot change idle timeout after "
		"the first peer has agreed to it."
		" %d connected peers\n",
		o2net_num_connected_peers());
		ret = -EINVAL;
		} else if (val <= cluster->cl_keepalive_delay_ms) {
		mlog(ML_NOTICE, "o2net: idle timeout must be larger "
		"than keepalive delay\n");
		ret = -EINVAL;
		} else {
		cluster->cl_idle_timeout_ms = val;
		}
		}

		return ret;
		}

		static ssize_t o2nm_cluster_attr_keepalive_delay_ms_read(
		struct o2nm_cluster cluster, char page)
		{
		return sprintf(page, "%u\n", cluster->cl_keepalive_delay_ms);
		}

		static ssize_t o2nm_cluster_attr_keepalive_delay_ms_write(
		struct o2nm_cluster cluster, const char page, size_t count)
		{
		ssize_t ret;
		unsigned int val;

		ret = o2nm_cluster_attr_write(page, count, &val);

		if (ret > 0) {
		if (cluster->cl_keepalive_delay_ms != val
		&& o2net_num_connected_peers()) {
		mlog(ML_NOTICE,
		"o2net: cannot change keepalive delay after"
		" the first peer has agreed to it."
		" %d connected peers\n",
		o2net_num_connected_peers());
		ret = -EINVAL;
		} else if (val >= cluster->cl_idle_timeout_ms) {
		mlog(ML_NOTICE, "o2net: keepalive delay must be "
		"smaller than idle timeout\n");
		ret = -EINVAL;
		} else {
		cluster->cl_keepalive_delay_ms = val;
		}
		}

		return ret;
		}

		static ssize_t o2nm_cluster_attr_reconnect_delay_ms_read(
		struct o2nm_cluster cluster, char page)
		{
		return sprintf(page, "%u\n", cluster->cl_reconnect_delay_ms);
		}

		static ssize_t o2nm_cluster_attr_reconnect_delay_ms_write(
		struct o2nm_cluster cluster, const char page, size_t count)
		{
		return o2nm_cluster_attr_write(page, count,
		&cluster->cl_reconnect_delay_ms);
		}
		static struct o2nm_cluster_attribute o2nm_cluster_attr_idle_timeout_ms = {
		.attr = { .ca_owner = THIS_MODULE,
		.ca_name = "idle_timeout_ms",
		.ca_mode = S_IRUGO \| S_IWUSR },
		.show = o2nm_cluster_attr_idle_timeout_ms_read,
		.store = o2nm_cluster_attr_idle_timeout_ms_write,
		};

		static struct o2nm_cluster_attribute o2nm_cluster_attr_keepalive_delay_ms = {
		.attr = { .ca_owner = THIS_MODULE,
		.ca_name = "keepalive_delay_ms",
		.ca_mode = S_IRUGO \| S_IWUSR },
		.show = o2nm_cluster_attr_keepalive_delay_ms_read,
		.store = o2nm_cluster_attr_keepalive_delay_ms_write,
		};

		static struct o2nm_cluster_attribute o2nm_cluster_attr_reconnect_delay_ms = {
		.attr = { .ca_owner = THIS_MODULE,
		.ca_name = "reconnect_delay_ms",
		.ca_mode = S_IRUGO \| S_IWUSR },
		.show = o2nm_cluster_attr_reconnect_delay_ms_read,
		.store = o2nm_cluster_attr_reconnect_delay_ms_write,
		};

		static struct configfs_attribute *o2nm_cluster_attrs[] = {
		&o2nm_cluster_attr_idle_timeout_ms.attr,
		&o2nm_cluster_attr_keepalive_delay_ms.attr,
		&o2nm_cluster_attr_reconnect_delay_ms.attr,
		NULL,
		};
		static ssize_t o2nm_cluster_show(struct config_item *item,
		struct configfs_attribute *attr,
		char *page)
		{
		struct o2nm_cluster *cluster = to_o2nm_cluster(item);
		struct o2nm_cluster_attribute *o2nm_cluster_attr =
		container_of(attr, struct o2nm_cluster_attribute, attr);
		ssize_t ret = 0;

		if (o2nm_cluster_attr->show)
		ret = o2nm_cluster_attr->show(cluster, page);
		return ret;
		}

		static ssize_t o2nm_cluster_store(struct config_item *item,
		struct configfs_attribute *attr,
		const char *page, size_t count)
		{
		struct o2nm_cluster *cluster = to_o2nm_cluster(item);
		struct o2nm_cluster_attribute *o2nm_cluster_attr =
		container_of(attr, struct o2nm_cluster_attribute, attr);
		ssize_t ret;

		if (o2nm_cluster_attr->store == NULL) {
		ret = -EINVAL;
		goto out;
		}

		ret = o2nm_cluster_attr->store(cluster, page, count);
		if (ret < count)
		goto out;
		out:
		return ret;
		}

		static struct config_item o2nm_node_group_make_item(struct config_group group,
		const char *name)
		{
		@@ -624,10 +786,13 @@ static void o2nm_cluster_release(struct config_item *item)

		static struct configfs_item_operations o2nm_cluster_item_ops = {
		.release = o2nm_cluster_release,
		.show_attribute = o2nm_cluster_show,
		.store_attribute = o2nm_cluster_store,
		};

		static struct config_item_type o2nm_cluster_type = {
		.ct_item_ops = &o2nm_cluster_item_ops,
		.ct_attrs = o2nm_cluster_attrs,
		.ct_owner = THIS_MODULE,
		};

		@@ -678,6 +843,9 @@ static struct config_group o2nm_cluster_group_make_group(struct config_group g
		cluster->cl_group.default_groups[2] = NULL;
		rwlock_init(&cluster->cl_nodes_lock);
		cluster->cl_node_ip_tree = RB_ROOT;
		cluster->cl_reconnect_delay_ms = O2NET_RECONNECT_DELAY_MS_DEFAULT;
		cluster->cl_idle_timeout_ms = O2NET_IDLE_TIMEOUT_MS_DEFAULT;
		cluster->cl_keepalive_delay_ms = O2NET_KEEPALIVE_DELAY_MS_DEFAULT;

		ret = &cluster->cl_group;
		o2nm_single_cluster = cluster;

fs/ocfs2/cluster/nodemanager.h

+17 −0

Original line number	Diff line number	Diff line
		@@ -53,6 +53,23 @@ struct o2nm_node {
		unsigned long nd_set_attributes;
		};

		struct o2nm_cluster {
		struct config_group cl_group;
		unsigned cl_has_local:1;
		u8 cl_local_node;
		rwlock_t cl_nodes_lock;
		struct o2nm_node *cl_nodes[O2NM_MAX_NODES];
		struct rb_root cl_node_ip_tree;
		unsigned int cl_idle_timeout_ms;
		unsigned int cl_keepalive_delay_ms;
		unsigned int cl_reconnect_delay_ms;

		/* this bitmap is part of a hack for disk bitmap.. will go eventually. - zab */
		unsigned long cl_nodes_bitmap[BITS_TO_LONGS(O2NM_MAX_NODES)];
		};

		extern struct o2nm_cluster *o2nm_single_cluster;

		u8 o2nm_this_node(void);

		int o2nm_configured_node_map(unsigned long *map, unsigned bytes);

fs/ocfs2/cluster/tcp.c

+131 −21

Original line number	Diff line number	Diff line
		@@ -147,6 +147,28 @@ static void o2net_listen_data_ready(struct sock *sk, int bytes);
		static void o2net_sc_send_keep_req(struct work_struct *work);
		static void o2net_idle_timer(unsigned long data);
		static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
		static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc);

		/*
		* FIXME: These should use to_o2nm_cluster_from_node(), but we end up
		* losing our parent link to the cluster during shutdown. This can be
		* solved by adding a pre-removal callback to configfs, or passing
		* around the cluster with the node. -jeffm
		*/
		static inline int o2net_reconnect_delay(struct o2nm_node *node)
		{
		return o2nm_single_cluster->cl_reconnect_delay_ms;
		}

		static inline int o2net_keepalive_delay(struct o2nm_node *node)
		{
		return o2nm_single_cluster->cl_keepalive_delay_ms;
		}

		static inline int o2net_idle_timeout(struct o2nm_node *node)
		{
		return o2nm_single_cluster->cl_idle_timeout_ms;
		}

		static inline int o2net_sys_err_to_errno(enum o2net_system_error err)
		{
		@@ -271,6 +293,8 @@ static void sc_kref_release(struct kref *kref)
		{
		struct o2net_sock_container *sc = container_of(kref,
		struct o2net_sock_container, sc_kref);
		BUG_ON(timer_pending(&sc->sc_idle_timeout));

		sclog(sc, "releasing\n");

		if (sc->sc_sock) {
		@@ -356,6 +380,13 @@ static void o2net_sc_cancel_delayed_work(struct o2net_sock_container *sc,
		sc_put(sc);
		}

		static atomic_t o2net_connected_peers = ATOMIC_INIT(0);

		int o2net_num_connected_peers(void)
		{
		return atomic_read(&o2net_connected_peers);
		}

		static void o2net_set_nn_state(struct o2net_node *nn,
		struct o2net_sock_container *sc,
		unsigned valid, int err)
		@@ -366,6 +397,11 @@ static void o2net_set_nn_state(struct o2net_node *nn,

		assert_spin_locked(&nn->nn_lock);

		if (old_sc && !sc)
		atomic_dec(&o2net_connected_peers);
		else if (!old_sc && sc)
		atomic_inc(&o2net_connected_peers);

		/* the node num comparison and single connect/accept path should stop
		* an non-null sc from being overwritten with another */
		BUG_ON(sc && nn->nn_sc && nn->nn_sc != sc);
		@@ -424,9 +460,9 @@ static void o2net_set_nn_state(struct o2net_node *nn,
		/* delay if we're withing a RECONNECT_DELAY of the
		* last attempt */
		delay = (nn->nn_last_connect_attempt +
		msecs_to_jiffies(O2NET_RECONNECT_DELAY_MS))
		msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
		- jiffies;
		if (delay > msecs_to_jiffies(O2NET_RECONNECT_DELAY_MS))
		if (delay > msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
		delay = 0;
		mlog(ML_CONN, "queueing conn attempt in %lu jiffies\n", delay);
		queue_delayed_work(o2net_wq, &nn->nn_connect_work, delay);
		@@ -1099,13 +1135,51 @@ static int o2net_check_handshake(struct o2net_sock_container *sc)
		return -1;
		}

		/*
		* Ensure timeouts are consistent with other nodes, otherwise
		* we can end up with one node thinking that the other must be down,
		* but isn't. This can ultimately cause corruption.
		*/
		if (be32_to_cpu(hand->o2net_idle_timeout_ms) !=
		o2net_idle_timeout(sc->sc_node)) {
		mlog(ML_NOTICE, SC_NODEF_FMT " uses a network idle timeout of "
		"%u ms, but we use %u ms locally. disconnecting\n",
		SC_NODEF_ARGS(sc),
		be32_to_cpu(hand->o2net_idle_timeout_ms),
		o2net_idle_timeout(sc->sc_node));
		o2net_ensure_shutdown(nn, sc, -ENOTCONN);
		return -1;
		}

		if (be32_to_cpu(hand->o2net_keepalive_delay_ms) !=
		o2net_keepalive_delay(sc->sc_node)) {
		mlog(ML_NOTICE, SC_NODEF_FMT " uses a keepalive delay of "
		"%u ms, but we use %u ms locally. disconnecting\n",
		SC_NODEF_ARGS(sc),
		be32_to_cpu(hand->o2net_keepalive_delay_ms),
		o2net_keepalive_delay(sc->sc_node));
		o2net_ensure_shutdown(nn, sc, -ENOTCONN);
		return -1;
		}

		if (be32_to_cpu(hand->o2hb_heartbeat_timeout_ms) !=
		O2HB_MAX_WRITE_TIMEOUT_MS) {
		mlog(ML_NOTICE, SC_NODEF_FMT " uses a heartbeat timeout of "
		"%u ms, but we use %u ms locally. disconnecting\n",
		SC_NODEF_ARGS(sc),
		be32_to_cpu(hand->o2hb_heartbeat_timeout_ms),
		O2HB_MAX_WRITE_TIMEOUT_MS);
		o2net_ensure_shutdown(nn, sc, -ENOTCONN);
		return -1;
		}

		sc->sc_handshake_ok = 1;

		spin_lock(&nn->nn_lock);
		/* set valid and queue the idle timers only if it hasn't been
		* shut down already */
		if (nn->nn_sc == sc) {
		o2net_sc_postpone_idle(sc);
		o2net_sc_reset_idle_timer(sc);
		o2net_set_nn_state(nn, sc, 1, 0);
		}
		spin_unlock(&nn->nn_lock);
		@@ -1131,22 +1205,30 @@ static int o2net_advance_rx(struct o2net_sock_container *sc)
		sclog(sc, "receiving\n");
		do_gettimeofday(&sc->sc_tv_advance_start);

		/* do we need more header? */
		if (sc->sc_page_off < sizeof(struct o2net_msg)) {
		if (unlikely(sc->sc_handshake_ok == 0)) {
		if(sc->sc_page_off < sizeof(struct o2net_handshake)) {
		data = page_address(sc->sc_page) + sc->sc_page_off;
		datalen = sizeof(struct o2net_msg) - sc->sc_page_off;
		datalen = sizeof(struct o2net_handshake) - sc->sc_page_off;
		ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
		if (ret > 0) {
		if (ret > 0)
		sc->sc_page_off += ret;
		}

		/* this working relies on the handshake being
		* smaller than the normal message header */
		if (sc->sc_page_off >= sizeof(struct o2net_handshake)&&
		!sc->sc_handshake_ok && o2net_check_handshake(sc)) {
		if (sc->sc_page_off == sizeof(struct o2net_handshake)) {
		o2net_check_handshake(sc);
		if (unlikely(sc->sc_handshake_ok == 0))
		ret = -EPROTO;
		}
		goto out;
		}

		/* do we need more header? */
		if (sc->sc_page_off < sizeof(struct o2net_msg)) {
		data = page_address(sc->sc_page) + sc->sc_page_off;
		datalen = sizeof(struct o2net_msg) - sc->sc_page_off;
		ret = o2net_recv_tcp_msg(sc->sc_sock, data, datalen);
		if (ret > 0) {
		sc->sc_page_off += ret;
		/* only swab incoming here.. we can
		* only get here once as we cross from
		* being under to over */
		@@ -1248,6 +1330,18 @@ static int o2net_set_nodelay(struct socket *sock)
		return ret;
		}

		static void o2net_initialize_handshake(void)
		{
		o2net_hand->o2hb_heartbeat_timeout_ms = cpu_to_be32(
		O2HB_MAX_WRITE_TIMEOUT_MS);
		o2net_hand->o2net_idle_timeout_ms = cpu_to_be32(
		o2net_idle_timeout(NULL));
		o2net_hand->o2net_keepalive_delay_ms = cpu_to_be32(
		o2net_keepalive_delay(NULL));
		o2net_hand->o2net_reconnect_delay_ms = cpu_to_be32(
		o2net_reconnect_delay(NULL));
		}

		/* ------------------------------------------------------------ */

		/* called when a connect completes and after a sock is accepted. the
		@@ -1262,6 +1356,7 @@ static void o2net_sc_connect_completed(struct work_struct *work)
		(unsigned long long)O2NET_PROTOCOL_VERSION,
		(unsigned long long)be64_to_cpu(o2net_hand->connector_id));

		o2net_initialize_handshake();
		o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));
		sc_put(sc);
		}
		@@ -1287,8 +1382,10 @@ static void o2net_idle_timer(unsigned long data)

		do_gettimeofday(&now);

		printk(KERN_INFO "o2net: connection to " SC_NODEF_FMT " has been idle for 10 "
		"seconds, shutting it down.\n", SC_NODEF_ARGS(sc));
		printk(KERN_INFO "o2net: connection to " SC_NODEF_FMT " has been idle for %u.%u "
		"seconds, shutting it down.\n", SC_NODEF_ARGS(sc),
		o2net_idle_timeout(sc->sc_node) / 1000,
		o2net_idle_timeout(sc->sc_node) % 1000);
		mlog(ML_NOTICE, "here are some times that might help debug the "
		"situation: (tmr %ld.%ld now %ld.%ld dr %ld.%ld adv "
		"%ld.%ld:%ld.%ld func (%08x:%u) %ld.%ld:%ld.%ld)\n",
		@@ -1306,14 +1403,21 @@ static void o2net_idle_timer(unsigned long data)
		o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
		}

		static void o2net_sc_postpone_idle(struct o2net_sock_container *sc)
		static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc)
		{
		o2net_sc_cancel_delayed_work(sc, &sc->sc_keepalive_work);
		o2net_sc_queue_delayed_work(sc, &sc->sc_keepalive_work,
		O2NET_KEEPALIVE_DELAY_SECS * HZ);
		msecs_to_jiffies(o2net_keepalive_delay(sc->sc_node)));
		do_gettimeofday(&sc->sc_tv_timer);
		mod_timer(&sc->sc_idle_timeout,
		jiffies + (O2NET_IDLE_TIMEOUT_SECS * HZ));
		jiffies + msecs_to_jiffies(o2net_idle_timeout(sc->sc_node)));
		}

		static void o2net_sc_postpone_idle(struct o2net_sock_container *sc)
		{
		/* Only push out an existing timer */
		if (timer_pending(&sc->sc_idle_timeout))
		o2net_sc_reset_idle_timer(sc);
		}

		/* this work func is kicked whenever a path sets the nn state which doesn't
		@@ -1435,9 +1539,12 @@ static void o2net_connect_expired(struct work_struct *work)

		spin_lock(&nn->nn_lock);
		if (!nn->nn_sc_valid) {
		struct o2nm_node *node = nn->nn_sc->sc_node;
		mlog(ML_ERROR, "no connection established with node %u after "
		"%u seconds, giving up and returning errors.\n",
		o2net_num_from_nn(nn), O2NET_IDLE_TIMEOUT_SECS);
		"%u.%u seconds, giving up and returning errors.\n",
		o2net_num_from_nn(nn),
		o2net_idle_timeout(node) / 1000,
		o2net_idle_timeout(node) % 1000);

		o2net_set_nn_state(nn, NULL, 0, -ENOTCONN);
		}
		@@ -1478,6 +1585,8 @@ static void o2net_hb_node_down_cb(struct o2nm_node *node, int node_num,

		if (node_num != o2nm_this_node())
		o2net_disconnect_node(node);

		BUG_ON(atomic_read(&o2net_connected_peers) < 0);
		}

		static void o2net_hb_node_up_cb(struct o2nm_node *node, int node_num,
		@@ -1489,14 +1598,14 @@ static void o2net_hb_node_up_cb(struct o2nm_node *node, int node_num,

		/* ensure an immediate connect attempt */
		nn->nn_last_connect_attempt = jiffies -
		(msecs_to_jiffies(O2NET_RECONNECT_DELAY_MS) + 1);
		(msecs_to_jiffies(o2net_reconnect_delay(node)) + 1);

		if (node_num != o2nm_this_node()) {
		/* heartbeat doesn't work unless a local node number is
		* configured and doing so brings up the o2net_wq, so we can
		* use it.. */
		queue_delayed_work(o2net_wq, &nn->nn_connect_expired,
		O2NET_IDLE_TIMEOUT_SECS * HZ);
		msecs_to_jiffies(o2net_idle_timeout(node)));

		/* believe it or not, accept and node hearbeating testing
		* can succeed for this node before we got here.. so
		@@ -1641,6 +1750,7 @@ static int o2net_accept_one(struct socket *sock)
		o2net_register_callbacks(sc->sc_sock->sk, sc);
		o2net_sc_queue_work(sc, &sc->sc_rx_work);

		o2net_initialize_handshake();
		o2net_sendpage(sc, o2net_hand, sizeof(*o2net_hand));

		out:

fs/ocfs2/cluster/tcp.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -54,6 +54,13 @@ typedef int (o2net_msg_handler_func)(struct o2net_msg msg, u32 len, void data)

		#define O2NET_MAX_PAYLOAD_BYTES (4096 - sizeof(struct o2net_msg))

		/* same as hb delay, we're waiting for another node to recognize our hb */
		#define O2NET_RECONNECT_DELAY_MS_DEFAULT 2000

		#define O2NET_KEEPALIVE_DELAY_MS_DEFAULT 5000
		#define O2NET_IDLE_TIMEOUT_MS_DEFAULT 10000


		/* TODO: figure this out.... */
		static inline int o2net_link_down(int err, struct socket *sock)
		{
		@@ -101,6 +108,7 @@ void o2net_unregister_hb_callbacks(void);
		int o2net_start_listening(struct o2nm_node *node);
		void o2net_stop_listening(struct o2nm_node *node);
		void o2net_disconnect_node(struct o2nm_node *node);
		int o2net_num_connected_peers(void);

		int o2net_init(void);
		void o2net_exit(void);