[deliverable/linux.git] / net / tipc / msg.h

/*
 * net/tipc/msg.h: Include file for TIPC message header routines
 *
 * Copyright (c) 2000-2007, 2014, Ericsson AB
 * Copyright (c) 2005-2008, 2010-2011, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _TIPC_MSG_H
#define _TIPC_MSG_H

#include "bearer.h"

/*
 * Constants and routines used to read and write TIPC payload message headers
 *
 * Note: Some items are also used with TIPC internal message headers
 */
#define TIPC_VERSION              2

/*
 * Payload message users are defined in TIPC's public API:
 * - TIPC_LOW_IMPORTANCE
 * - TIPC_MEDIUM_IMPORTANCE
 * - TIPC_HIGH_IMPORTANCE
 * - TIPC_CRITICAL_IMPORTANCE
 */

/*
 * Payload message types
 */
#define TIPC_CONN_MSG		0
#define TIPC_MCAST_MSG		1
#define TIPC_NAMED_MSG		2
#define TIPC_DIRECT_MSG		3

/*
 * Message header sizes
 */
#define SHORT_H_SIZE              24	/* In-cluster basic payload message */
#define BASIC_H_SIZE              32	/* Basic payload message */
#define NAMED_H_SIZE              40	/* Named payload message */
#define MCAST_H_SIZE              44	/* Multicast payload message */
#define INT_H_SIZE                40	/* Internal messages */
#define MIN_H_SIZE                24	/* Smallest legal TIPC header size */
#define MAX_H_SIZE                60	/* Largest possible TIPC header size */

#define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)

#define TIPC_MEDIA_ADDR_OFFSET	5


struct tipc_msg {
	__be32 hdr[15];
};


static inline u32 msg_word(struct tipc_msg *m, u32 pos)
{
	return ntohl(m->hdr[pos]);
}

static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
{
	m->hdr[w] = htonl(val);
}

static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
{
	return (msg_word(m, w) >> pos) & mask;
}

static inline void msg_set_bits(struct tipc_msg *m, u32 w,
				u32 pos, u32 mask, u32 val)
{
	val = (val & mask) << pos;
	mask = mask << pos;
	m->hdr[w] &= ~htonl(mask);
	m->hdr[w] |= htonl(val);
}

static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)
{
	u32 temp = msg->hdr[a];

	msg->hdr[a] = msg->hdr[b];
	msg->hdr[b] = temp;
}

/*
 * Word 0
 */
static inline u32 msg_version(struct tipc_msg *m)
{
	return msg_bits(m, 0, 29, 7);
}

static inline void msg_set_version(struct tipc_msg *m)
{
	msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
}

static inline u32 msg_user(struct tipc_msg *m)
{
	return msg_bits(m, 0, 25, 0xf);
}

static inline u32 msg_isdata(struct tipc_msg *m)
{
	return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
}

static inline void msg_set_user(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 0, 25, 0xf, n);
}

static inline u32 msg_importance(struct tipc_msg *m)
{
	return msg_bits(m, 0, 25, 0xf);
}

static inline void msg_set_importance(struct tipc_msg *m, u32 i)
{
	msg_set_user(m, i);
}

static inline u32 msg_hdr_sz(struct tipc_msg *m)
{
	return msg_bits(m, 0, 21, 0xf) << 2;
}

static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 0, 21, 0xf, n>>2);
}

static inline u32 msg_size(struct tipc_msg *m)
{
	return msg_bits(m, 0, 0, 0x1ffff);
}

static inline u32 msg_data_sz(struct tipc_msg *m)
{
	return msg_size(m) - msg_hdr_sz(m);
}

static inline int msg_non_seq(struct tipc_msg *m)
{
	return msg_bits(m, 0, 20, 1);
}

static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 0, 20, 1, n);
}

static inline int msg_dest_droppable(struct tipc_msg *m)
{
	return msg_bits(m, 0, 19, 1);
}

static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
{
	msg_set_bits(m, 0, 19, 1, d);
}

static inline int msg_src_droppable(struct tipc_msg *m)
{
	return msg_bits(m, 0, 18, 1);
}

static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
{
	msg_set_bits(m, 0, 18, 1, d);
}

static inline void msg_set_size(struct tipc_msg *m, u32 sz)
{
	m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz);
}


/*
 * Word 1
 */
static inline u32 msg_type(struct tipc_msg *m)
{
	return msg_bits(m, 1, 29, 0x7);
}

static inline void msg_set_type(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 1, 29, 0x7, n);
}

static inline u32 msg_named(struct tipc_msg *m)
{
	return msg_type(m) == TIPC_NAMED_MSG;
}

static inline u32 msg_mcast(struct tipc_msg *m)
{
	return msg_type(m) == TIPC_MCAST_MSG;
}

static inline u32 msg_connected(struct tipc_msg *m)
{
	return msg_type(m) == TIPC_CONN_MSG;
}

static inline u32 msg_errcode(struct tipc_msg *m)
{
	return msg_bits(m, 1, 25, 0xf);
}

static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
{
	msg_set_bits(m, 1, 25, 0xf, err);
}

static inline u32 msg_reroute_cnt(struct tipc_msg *m)
{
	return msg_bits(m, 1, 21, 0xf);
}

static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
{
	msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
}

static inline void msg_reset_reroute_cnt(struct tipc_msg *m)
{
	msg_set_bits(m, 1, 21, 0xf, 0);
}

static inline u32 msg_lookup_scope(struct tipc_msg *m)
{
	return msg_bits(m, 1, 19, 0x3);
}

static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 1, 19, 0x3, n);
}

static inline u32 msg_bcast_ack(struct tipc_msg *m)
{
	return msg_bits(m, 1, 0, 0xffff);
}

static inline void msg_set_bcast_ack(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 1, 0, 0xffff, n);
}


/*
 * Word 2
 */
static inline u32 msg_ack(struct tipc_msg *m)
{
	return msg_bits(m, 2, 16, 0xffff);
}

static inline void msg_set_ack(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 2, 16, 0xffff, n);
}

static inline u32 msg_seqno(struct tipc_msg *m)
{
	return msg_bits(m, 2, 0, 0xffff);
}

static inline void msg_set_seqno(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 2, 0, 0xffff, n);
}

/*
 * Words 3-10
 */
static inline u32 msg_prevnode(struct tipc_msg *m)
{
	return msg_word(m, 3);
}

static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
{
	msg_set_word(m, 3, a);
}

static inline u32 msg_origport(struct tipc_msg *m)
{
	return msg_word(m, 4);
}

static inline void msg_set_origport(struct tipc_msg *m, u32 p)
{
	msg_set_word(m, 4, p);
}

static inline u32 msg_destport(struct tipc_msg *m)
{
	return msg_word(m, 5);
}

static inline void msg_set_destport(struct tipc_msg *m, u32 p)
{
	msg_set_word(m, 5, p);
}

static inline u32 msg_mc_netid(struct tipc_msg *m)
{
	return msg_word(m, 5);
}

static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
{
	msg_set_word(m, 5, p);
}

static inline int msg_short(struct tipc_msg *m)
{
	return msg_hdr_sz(m) == SHORT_H_SIZE;
}

static inline u32 msg_orignode(struct tipc_msg *m)
{
	if (likely(msg_short(m)))
		return msg_prevnode(m);
	return msg_word(m, 6);
}

static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
{
	msg_set_word(m, 6, a);
}

static inline u32 msg_destnode(struct tipc_msg *m)
{
	return msg_word(m, 7);
}

static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
{
	msg_set_word(m, 7, a);
}

static inline u32 msg_nametype(struct tipc_msg *m)
{
	return msg_word(m, 8);
}

static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
{
	msg_set_word(m, 8, n);
}

static inline u32 msg_nameinst(struct tipc_msg *m)
{
	return msg_word(m, 9);
}

static inline u32 msg_namelower(struct tipc_msg *m)
{
	return msg_nameinst(m);
}

static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
{
	msg_set_word(m, 9, n);
}

static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
{
	msg_set_namelower(m, n);
}

static inline u32 msg_nameupper(struct tipc_msg *m)
{
	return msg_word(m, 10);
}

static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
{
	msg_set_word(m, 10, n);
}

static inline unchar *msg_data(struct tipc_msg *m)
{
	return ((unchar *)m) + msg_hdr_sz(m);
}

static inline struct tipc_msg *msg_get_wrapped(struct tipc_msg *m)
{
	return (struct tipc_msg *)msg_data(m);
}

/*
 * Constants and routines used to read and write TIPC internal message headers
 */

/*
 * Internal message users
 */
#define  BCAST_PROTOCOL       5
#define  MSG_BUNDLER          6
#define  LINK_PROTOCOL        7
#define  CONN_MANAGER         8
#define  ROUTE_DISTRIBUTOR    9		/* obsoleted */
#define  CHANGEOVER_PROTOCOL  10
#define  NAME_DISTRIBUTOR     11
#define  MSG_FRAGMENTER       12
#define  LINK_CONFIG          13
#define  SOCK_WAKEUP          14       /* pseudo user */

/*
 *  Connection management protocol message types
 */
#define CONN_PROBE        0
#define CONN_PROBE_REPLY  1
#define CONN_ACK          2

/*
 * Name distributor message types
 */
#define PUBLICATION       0
#define WITHDRAWAL        1

/*
 * Segmentation message types
 */
#define FIRST_FRAGMENT		0
#define FRAGMENT		1
#define LAST_FRAGMENT		2

/* Bundling protocol message types
 */
#define BUNDLE_OPEN             0
#define BUNDLE_CLOSED           1

/*
 * Link management protocol message types
 */
#define STATE_MSG		0
#define RESET_MSG		1
#define ACTIVATE_MSG		2

/*
 * Changeover tunnel message types
 */
#define DUPLICATE_MSG		0
#define ORIGINAL_MSG		1

/*
 * Config protocol message types
 */
#define DSC_REQ_MSG		0
#define DSC_RESP_MSG		1


/*
 * Word 1
 */
static inline u32 msg_seq_gap(struct tipc_msg *m)
{
	return msg_bits(m, 1, 16, 0x1fff);
}

static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 1, 16, 0x1fff, n);
}

static inline u32 msg_node_sig(struct tipc_msg *m)
{
	return msg_bits(m, 1, 0, 0xffff);
}

static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 1, 0, 0xffff, n);
}


/*
 * Word 2
 */
static inline u32 msg_dest_domain(struct tipc_msg *m)
{
	return msg_word(m, 2);
}

static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
{
	msg_set_word(m, 2, n);
}

static inline u32 msg_bcgap_after(struct tipc_msg *m)
{
	return msg_bits(m, 2, 16, 0xffff);
}

static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 2, 16, 0xffff, n);
}

static inline u32 msg_bcgap_to(struct tipc_msg *m)
{
	return msg_bits(m, 2, 0, 0xffff);
}

static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 2, 0, 0xffff, n);
}


/*
 * Word 4
 */
static inline u32 msg_last_bcast(struct tipc_msg *m)
{
	return msg_bits(m, 4, 16, 0xffff);
}

static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 4, 16, 0xffff, n);
}

static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 4, 16, 0xffff, n);
}


static inline u32 msg_next_sent(struct tipc_msg *m)
{
	return msg_bits(m, 4, 0, 0xffff);
}

static inline void msg_set_next_sent(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 4, 0, 0xffff, n);
}

static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 4, 0, 0xffff, n);
}

static inline u32 msg_bc_netid(struct tipc_msg *m)
{
	return msg_word(m, 4);
}

static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
{
	msg_set_word(m, 4, id);
}

static inline u32 msg_link_selector(struct tipc_msg *m)
{
	return msg_bits(m, 4, 0, 1);
}

static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 4, 0, 1, n);
}

/*
 * Word 5
 */
static inline u32 msg_session(struct tipc_msg *m)
{
	return msg_bits(m, 5, 16, 0xffff);
}

static inline void msg_set_session(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 5, 16, 0xffff, n);
}

static inline u32 msg_probe(struct tipc_msg *m)
{
	return msg_bits(m, 5, 0, 1);
}

static inline void msg_set_probe(struct tipc_msg *m, u32 val)
{
	msg_set_bits(m, 5, 0, 1, val);
}

static inline char msg_net_plane(struct tipc_msg *m)
{
	return msg_bits(m, 5, 1, 7) + 'A';
}

static inline void msg_set_net_plane(struct tipc_msg *m, char n)
{
	msg_set_bits(m, 5, 1, 7, (n - 'A'));
}

static inline u32 msg_linkprio(struct tipc_msg *m)
{
	return msg_bits(m, 5, 4, 0x1f);
}

static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 5, 4, 0x1f, n);
}

static inline u32 msg_bearer_id(struct tipc_msg *m)
{
	return msg_bits(m, 5, 9, 0x7);
}

static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 5, 9, 0x7, n);
}

static inline u32 msg_redundant_link(struct tipc_msg *m)
{
	return msg_bits(m, 5, 12, 0x1);
}

static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
{
	msg_set_bits(m, 5, 12, 0x1, r);
}

static inline char *msg_media_addr(struct tipc_msg *m)
{
	return (char *)&m->hdr[TIPC_MEDIA_ADDR_OFFSET];
}

/*
 * Word 9
 */
static inline u32 msg_msgcnt(struct tipc_msg *m)
{
	return msg_bits(m, 9, 16, 0xffff);
}

static inline void msg_set_msgcnt(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 9, 16, 0xffff, n);
}

static inline u32 msg_bcast_tag(struct tipc_msg *m)
{
	return msg_bits(m, 9, 16, 0xffff);
}

static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 9, 16, 0xffff, n);
}

static inline u32 msg_max_pkt(struct tipc_msg *m)
{
	return msg_bits(m, 9, 16, 0xffff) * 4;
}

static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 9, 16, 0xffff, (n / 4));
}

static inline u32 msg_link_tolerance(struct tipc_msg *m)
{
	return msg_bits(m, 9, 0, 0xffff);
}

static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
{
	msg_set_bits(m, 9, 0, 0xffff, n);
}

static inline u32 tipc_msg_tot_importance(struct tipc_msg *m)
{
	if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
		return msg_importance(msg_get_wrapped(m));
	return msg_importance(m);
}

static inline u32 msg_tot_origport(struct tipc_msg *m)
{
	if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
		return msg_origport(msg_get_wrapped(m));
	return msg_origport(m);
}

bool tipc_msg_reverse(struct sk_buff *buf, u32 *dnode, int err);

int tipc_msg_eval(struct sk_buff *buf, u32 *dnode);

void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize,
		   u32 destnode);

struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
				uint data_sz, u32 dnode, u32 onode,
				u32 dport, u32 oport, int errcode);

int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);

bool tipc_msg_bundle(struct sk_buff *bbuf, struct sk_buff *buf, u32 mtu);

bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode);

int tipc_msg_build(struct tipc_msg *mhdr, struct iovec const *iov,
		   int offset, int dsz, int mtu , struct sk_buff **chain);

struct sk_buff *tipc_msg_reassemble(struct sk_buff *chain);

#endif
Commit	Line	Data
b97bf3fd PL	1	/*
b97bf3fd PL	2	* net/tipc/msg.h: Include file for TIPC message header routines
c4307285	3	*
37e22164	4	* Copyright (c) 2000-2007, 2014, Ericsson AB
741de3e9	5	* Copyright (c) 2005-2008, 2010-2011, Wind River Systems
b97bf3fd PL	6	* All rights reserved.
b97bf3fd PL	7	*
9ea1fd3c	8	* Redistribution and use in source and binary forms, with or without
b97bf3fd PL	9	* modification, are permitted provided that the following conditions are met:
b97bf3fd PL	10	*
9ea1fd3c PL	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the names of the copyright holders nor the names of its
	17	* contributors may be used to endorse or promote products derived from
	18	* this software without specific prior written permission.
b97bf3fd	19	*
9ea1fd3c PL	20	* Alternatively, this software may be distributed under the terms of the
	21	* GNU General Public License ("GPL") version 2 as published by the Free
	22	* Software Foundation.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
b97bf3fd PL	34	* POSSIBILITY OF SUCH DAMAGE.
	35	*/
	36
	37	#ifndef _TIPC_MSG_H
	38	#define _TIPC_MSG_H
	39
d265fef6	40	#include "bearer.h"
b97bf3fd	41
cc4c4353 AS	42	/*
	43	* Constants and routines used to read and write TIPC payload message headers
	44	*
	45	* Note: Some items are also used with TIPC internal message headers
	46	*/
b97bf3fd	47	#define TIPC_VERSION 2
06d82c91	48
d265fef6	49	/*
cc4c4353 AS	50	* Payload message users are defined in TIPC's public API:
	51	* - TIPC_LOW_IMPORTANCE
	52	* - TIPC_MEDIUM_IMPORTANCE
	53	* - TIPC_HIGH_IMPORTANCE
	54	* - TIPC_CRITICAL_IMPORTANCE
	55	*/
	56
	57	/*
	58	* Payload message types
d265fef6	59	*/
d265fef6 AS	60	#define TIPC_CONN_MSG 0
	61	#define TIPC_MCAST_MSG 1
	62	#define TIPC_NAMED_MSG 2
	63	#define TIPC_DIRECT_MSG 3
	64
cc4c4353 AS	65	/*
	66	* Message header sizes
	67	*/
741d9eb7 AS	68	#define SHORT_H_SIZE 24 /* In-cluster basic payload message */
	69	#define BASIC_H_SIZE 32 /* Basic payload message */
	70	#define NAMED_H_SIZE 40 /* Named payload message */
	71	#define MCAST_H_SIZE 44 /* Multicast payload message */
06d82c91 AS	72	#define INT_H_SIZE 40 /* Internal messages */
	73	#define MIN_H_SIZE 24 /* Smallest legal TIPC header size */
	74	#define MAX_H_SIZE 60 /* Largest possible TIPC header size */
	75
b97bf3fd	76	#define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
b97bf3fd	77
3d749a6a AS	78	#define TIPC_MEDIA_ADDR_OFFSET 5
3d749a6a AS	79
b97bf3fd	80
d265fef6 AS	81	struct tipc_msg {
	82	__be32 hdr[15];
	83	};
c4307285	84
b97bf3fd	85
d265fef6 AS	86	static inline u32 msg_word(struct tipc_msg *m, u32 pos)
	87	{
	88	return ntohl(m->hdr[pos]);
	89	}
b97bf3fd PL	90
	91	static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
	92	{
	93	m->hdr[w] = htonl(val);
	94	}
	95
d265fef6 AS	96	static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
	97	{
	98	return (msg_word(m, w) >> pos) & mask;
	99	}
	100
b97bf3fd PL	101	static inline void msg_set_bits(struct tipc_msg *m, u32 w,
	102	u32 pos, u32 mask, u32 val)
	103	{
1f9eda7e	104	val = (val & mask) << pos;
becf3da2 AV	105	mask = mask << pos;
	106	m->hdr[w] &= ~htonl(mask);
	107	m->hdr[w] \|= htonl(val);
b97bf3fd PL	108	}
b97bf3fd PL	109
40aecb1b AS	110	static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)
	111	{
	112	u32 temp = msg->hdr[a];
	113
	114	msg->hdr[a] = msg->hdr[b];
	115	msg->hdr[b] = temp;
	116	}
	117
c4307285	118	/*
b97bf3fd PL	119	* Word 0
b97bf3fd PL	120	*/
b97bf3fd PL	121	static inline u32 msg_version(struct tipc_msg *m)
	122	{
	123	return msg_bits(m, 0, 29, 7);
	124	}
	125
c4307285	126	static inline void msg_set_version(struct tipc_msg *m)
b97bf3fd	127	{
37695420	128	msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
b97bf3fd PL	129	}
	130
	131	static inline u32 msg_user(struct tipc_msg *m)
	132	{
	133	return msg_bits(m, 0, 25, 0xf);
	134	}
	135
	136	static inline u32 msg_isdata(struct tipc_msg *m)
	137	{
a02cec21	138	return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
b97bf3fd PL	139	}
b97bf3fd PL	140
c4307285	141	static inline void msg_set_user(struct tipc_msg *m, u32 n)
b97bf3fd PL	142	{
	143	msg_set_bits(m, 0, 25, 0xf, n);
	144	}
	145
d265fef6 AS	146	static inline u32 msg_importance(struct tipc_msg *m)
	147	{
	148	return msg_bits(m, 0, 25, 0xf);
	149	}
	150
c4307285	151	static inline void msg_set_importance(struct tipc_msg *m, u32 i)
b97bf3fd PL	152	{
	153	msg_set_user(m, i);
	154	}
	155
d265fef6 AS	156	static inline u32 msg_hdr_sz(struct tipc_msg *m)
	157	{
	158	return msg_bits(m, 0, 21, 0xf) << 2;
	159	}
	160
0e65967e	161	static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
b97bf3fd PL	162	{
	163	msg_set_bits(m, 0, 21, 0xf, n>>2);
	164	}
	165
d265fef6 AS	166	static inline u32 msg_size(struct tipc_msg *m)
	167	{
	168	return msg_bits(m, 0, 0, 0x1ffff);
	169	}
	170
	171	static inline u32 msg_data_sz(struct tipc_msg *m)
	172	{
	173	return msg_size(m) - msg_hdr_sz(m);
	174	}
	175
c4307285	176	static inline int msg_non_seq(struct tipc_msg *m)
b97bf3fd PL	177	{
	178	return msg_bits(m, 0, 20, 1);
	179	}
	180
40aecb1b	181	static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
b97bf3fd	182	{
40aecb1b	183	msg_set_bits(m, 0, 20, 1, n);
b97bf3fd PL	184	}
b97bf3fd PL	185
c4307285	186	static inline int msg_dest_droppable(struct tipc_msg *m)
b97bf3fd PL	187	{
	188	return msg_bits(m, 0, 19, 1);
	189	}
	190
c4307285	191	static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
b97bf3fd PL	192	{
	193	msg_set_bits(m, 0, 19, 1, d);
	194	}
	195
c4307285	196	static inline int msg_src_droppable(struct tipc_msg *m)
b97bf3fd PL	197	{
	198	return msg_bits(m, 0, 18, 1);
	199	}
	200
c4307285	201	static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
b97bf3fd PL	202	{
	203	msg_set_bits(m, 0, 18, 1, d);
	204	}
	205
	206	static inline void msg_set_size(struct tipc_msg *m, u32 sz)
	207	{
	208	m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) \| sz);
	209	}
	210
	211
c4307285	212	/*
b97bf3fd PL	213	* Word 1
b97bf3fd PL	214	*/
d265fef6 AS	215	static inline u32 msg_type(struct tipc_msg *m)
	216	{
	217	return msg_bits(m, 1, 29, 0x7);
	218	}
	219
c4307285	220	static inline void msg_set_type(struct tipc_msg *m, u32 n)
b97bf3fd PL	221	{
	222	msg_set_bits(m, 1, 29, 0x7, n);
	223	}
	224
d265fef6 AS	225	static inline u32 msg_named(struct tipc_msg *m)
	226	{
	227	return msg_type(m) == TIPC_NAMED_MSG;
	228	}
	229
	230	static inline u32 msg_mcast(struct tipc_msg *m)
	231	{
	232	return msg_type(m) == TIPC_MCAST_MSG;
	233	}
	234
	235	static inline u32 msg_connected(struct tipc_msg *m)
	236	{
	237	return msg_type(m) == TIPC_CONN_MSG;
	238	}
	239
	240	static inline u32 msg_errcode(struct tipc_msg *m)
	241	{
	242	return msg_bits(m, 1, 25, 0xf);
	243	}
	244
c4307285	245	static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
b97bf3fd PL	246	{
	247	msg_set_bits(m, 1, 25, 0xf, err);
	248	}
	249
c4307285	250	static inline u32 msg_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	251	{
	252	return msg_bits(m, 1, 21, 0xf);
	253	}
	254
c4307285	255	static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	256	{
	257	msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
	258	}
	259
c4307285	260	static inline void msg_reset_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	261	{
	262	msg_set_bits(m, 1, 21, 0xf, 0);
	263	}
	264
	265	static inline u32 msg_lookup_scope(struct tipc_msg *m)
	266	{
	267	return msg_bits(m, 1, 19, 0x3);
	268	}
	269
c4307285	270	static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
b97bf3fd PL	271	{
	272	msg_set_bits(m, 1, 19, 0x3, n);
	273	}
	274
b97bf3fd PL	275	static inline u32 msg_bcast_ack(struct tipc_msg *m)
	276	{
	277	return msg_bits(m, 1, 0, 0xffff);
	278	}
	279
c4307285	280	static inline void msg_set_bcast_ack(struct tipc_msg *m, u32 n)
b97bf3fd PL	281	{
	282	msg_set_bits(m, 1, 0, 0xffff, n);
	283	}
	284
	285
c4307285	286	/*
b97bf3fd PL	287	* Word 2
b97bf3fd PL	288	*/
b97bf3fd PL	289	static inline u32 msg_ack(struct tipc_msg *m)
	290	{
	291	return msg_bits(m, 2, 16, 0xffff);
	292	}
	293
c4307285	294	static inline void msg_set_ack(struct tipc_msg *m, u32 n)
b97bf3fd PL	295	{
	296	msg_set_bits(m, 2, 16, 0xffff, n);
	297	}
	298
	299	static inline u32 msg_seqno(struct tipc_msg *m)
	300	{
	301	return msg_bits(m, 2, 0, 0xffff);
	302	}
	303
c4307285	304	static inline void msg_set_seqno(struct tipc_msg *m, u32 n)
b97bf3fd PL	305	{
	306	msg_set_bits(m, 2, 0, 0xffff, n);
	307	}
	308
c4307285	309	/*
b97bf3fd PL	310	* Words 3-10
b97bf3fd PL	311	*/
d265fef6 AS	312	static inline u32 msg_prevnode(struct tipc_msg *m)
	313	{
	314	return msg_word(m, 3);
	315	}
	316
c4307285	317	static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
b97bf3fd PL	318	{
	319	msg_set_word(m, 3, a);
	320	}
	321
d265fef6 AS	322	static inline u32 msg_origport(struct tipc_msg *m)
	323	{
	324	return msg_word(m, 4);
	325	}
	326
c4307285	327	static inline void msg_set_origport(struct tipc_msg *m, u32 p)
b97bf3fd PL	328	{
	329	msg_set_word(m, 4, p);
	330	}
	331
d265fef6 AS	332	static inline u32 msg_destport(struct tipc_msg *m)
	333	{
	334	return msg_word(m, 5);
	335	}
	336
c4307285	337	static inline void msg_set_destport(struct tipc_msg *m, u32 p)
b97bf3fd PL	338	{
	339	msg_set_word(m, 5, p);
	340	}
	341
d265fef6 AS	342	static inline u32 msg_mc_netid(struct tipc_msg *m)
	343	{
	344	return msg_word(m, 5);
	345	}
	346
c4307285	347	static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
b97bf3fd PL	348	{
	349	msg_set_word(m, 5, p);
	350	}
	351
d265fef6 AS	352	static inline int msg_short(struct tipc_msg *m)
d265fef6 AS	353	{
741d9eb7	354	return msg_hdr_sz(m) == SHORT_H_SIZE;
d265fef6 AS	355	}
	356
	357	static inline u32 msg_orignode(struct tipc_msg *m)
	358	{
	359	if (likely(msg_short(m)))
	360	return msg_prevnode(m);
	361	return msg_word(m, 6);
	362	}
	363
c4307285	364	static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
b97bf3fd PL	365	{
	366	msg_set_word(m, 6, a);
	367	}
	368
d265fef6 AS	369	static inline u32 msg_destnode(struct tipc_msg *m)
	370	{
	371	return msg_word(m, 7);
	372	}
	373
c4307285	374	static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
b97bf3fd PL	375	{
	376	msg_set_word(m, 7, a);
	377	}
	378
d265fef6 AS	379	static inline u32 msg_nametype(struct tipc_msg *m)
	380	{
	381	return msg_word(m, 8);
	382	}
	383
c4307285	384	static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
b97bf3fd PL	385	{
	386	msg_set_word(m, 8, n);
	387	}
	388
d265fef6 AS	389	static inline u32 msg_nameinst(struct tipc_msg *m)
	390	{
	391	return msg_word(m, 9);
	392	}
	393
	394	static inline u32 msg_namelower(struct tipc_msg *m)
	395	{
	396	return msg_nameinst(m);
	397	}
	398
c4307285	399	static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
b97bf3fd PL	400	{
	401	msg_set_word(m, 9, n);
	402	}
	403
c4307285	404	static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
b97bf3fd PL	405	{
	406	msg_set_namelower(m, n);
	407	}
	408
d265fef6 AS	409	static inline u32 msg_nameupper(struct tipc_msg *m)
	410	{
	411	return msg_word(m, 10);
	412	}
	413
c4307285	414	static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
b97bf3fd PL	415	{
	416	msg_set_word(m, 10, n);
	417	}
	418
d265fef6 AS	419	static inline unchar msg_data(struct tipc_msg m)
	420	{
	421	return ((unchar *)m) + msg_hdr_sz(m);
	422	}
	423
b97bf3fd PL	424	static inline struct tipc_msg msg_get_wrapped(struct tipc_msg m)
	425	{
	426	return (struct tipc_msg *)msg_data(m);
	427	}
	428
b97bf3fd	429	/*
cc4c4353 AS	430	* Constants and routines used to read and write TIPC internal message headers
cc4c4353 AS	431	*/
b97bf3fd	432
c4307285	433	/*
cc4c4353	434	* Internal message users
b97bf3fd	435	*/
b97bf3fd PL	436	#define BCAST_PROTOCOL 5
	437	#define MSG_BUNDLER 6
	438	#define LINK_PROTOCOL 7
	439	#define CONN_MANAGER 8
51a8e4de	440	#define ROUTE_DISTRIBUTOR 9 /* obsoleted */
b97bf3fd PL	441	#define CHANGEOVER_PROTOCOL 10
	442	#define NAME_DISTRIBUTOR 11
	443	#define MSG_FRAGMENTER 12
	444	#define LINK_CONFIG 13
50100a5e	445	#define SOCK_WAKEUP 14 /* pseudo user */
b97bf3fd	446
c4307285	447	/*
cc4c4353	448	* Connection management protocol message types
b97bf3fd	449	*/
b97bf3fd PL	450	#define CONN_PROBE 0
	451	#define CONN_PROBE_REPLY 1
	452	#define CONN_ACK 2
	453
c4307285	454	/*
cc4c4353	455	* Name distributor message types
b97bf3fd	456	*/
b97bf3fd PL	457	#define PUBLICATION 0
	458	#define WITHDRAWAL 1
	459
92138d1f AS	460	/*
	461	* Segmentation message types
	462	*/
92138d1f AS	463	#define FIRST_FRAGMENT 0
	464	#define FRAGMENT 1
	465	#define LAST_FRAGMENT 2
	466
4f1688b2 JPM	467	/* Bundling protocol message types
	468	*/
	469	#define BUNDLE_OPEN 0
	470	#define BUNDLE_CLOSED 1
	471
92138d1f AS	472	/*
	473	* Link management protocol message types
	474	*/
92138d1f AS	475	#define STATE_MSG 0
	476	#define RESET_MSG 1
	477	#define ACTIVATE_MSG 2
	478
	479	/*
	480	* Changeover tunnel message types
	481	*/
	482	#define DUPLICATE_MSG 0
	483	#define ORIGINAL_MSG 1
	484
	485	/*
	486	* Config protocol message types
	487	*/
92138d1f AS	488	#define DSC_REQ_MSG 0
	489	#define DSC_RESP_MSG 1
	490
b97bf3fd	491
c4307285	492	/*
b97bf3fd PL	493	* Word 1
b97bf3fd PL	494	*/
b97bf3fd PL	495	static inline u32 msg_seq_gap(struct tipc_msg *m)
b97bf3fd PL	496	{
bd784533	497	return msg_bits(m, 1, 16, 0x1fff);
b97bf3fd PL	498	}
	499
	500	static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
	501	{
bd784533	502	msg_set_bits(m, 1, 16, 0x1fff, n);
b97bf3fd PL	503	}
b97bf3fd PL	504
fc0eea69 AS	505	static inline u32 msg_node_sig(struct tipc_msg *m)
	506	{
	507	return msg_bits(m, 1, 0, 0xffff);
	508	}
	509
	510	static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
	511	{
	512	msg_set_bits(m, 1, 0, 0xffff, n);
	513	}
	514
b97bf3fd	515
c4307285	516	/*
b97bf3fd PL	517	* Word 2
b97bf3fd PL	518	*/
b97bf3fd PL	519	static inline u32 msg_dest_domain(struct tipc_msg *m)
	520	{
	521	return msg_word(m, 2);
	522	}
	523
c4307285	524	static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
b97bf3fd PL	525	{
	526	msg_set_word(m, 2, n);
	527	}
	528
	529	static inline u32 msg_bcgap_after(struct tipc_msg *m)
	530	{
	531	return msg_bits(m, 2, 16, 0xffff);
	532	}
	533
	534	static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
	535	{
	536	msg_set_bits(m, 2, 16, 0xffff, n);
	537	}
	538
	539	static inline u32 msg_bcgap_to(struct tipc_msg *m)
	540	{
	541	return msg_bits(m, 2, 0, 0xffff);
	542	}
	543
c4307285	544	static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
b97bf3fd PL	545	{
	546	msg_set_bits(m, 2, 0, 0xffff, n);
	547	}
	548
	549
c4307285	550	/*
b97bf3fd PL	551	* Word 4
b97bf3fd PL	552	*/
b97bf3fd PL	553	static inline u32 msg_last_bcast(struct tipc_msg *m)
	554	{
	555	return msg_bits(m, 4, 16, 0xffff);
	556	}
	557
	558	static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
	559	{
	560	msg_set_bits(m, 4, 16, 0xffff, n);
	561	}
	562
b97bf3fd PL	563	static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
	564	{
	565	msg_set_bits(m, 4, 16, 0xffff, n);
	566	}
	567
	568
	569	static inline u32 msg_next_sent(struct tipc_msg *m)
	570	{
	571	return msg_bits(m, 4, 0, 0xffff);
	572	}
	573
	574	static inline void msg_set_next_sent(struct tipc_msg *m, u32 n)
	575	{
	576	msg_set_bits(m, 4, 0, 0xffff, n);
	577	}
	578
b97bf3fd PL	579	static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
	580	{
	581	msg_set_bits(m, 4, 0, 0xffff, n);
	582	}
	583
	584	static inline u32 msg_bc_netid(struct tipc_msg *m)
	585	{
	586	return msg_word(m, 4);
	587	}
	588
	589	static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
	590	{
	591	msg_set_word(m, 4, id);
	592	}
	593
	594	static inline u32 msg_link_selector(struct tipc_msg *m)
	595	{
	596	return msg_bits(m, 4, 0, 1);
	597	}
	598
	599	static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
	600	{
7eb878ed	601	msg_set_bits(m, 4, 0, 1, n);
b97bf3fd PL	602	}
b97bf3fd PL	603
c4307285	604	/*
b97bf3fd PL	605	* Word 5
b97bf3fd PL	606	*/
b97bf3fd PL	607	static inline u32 msg_session(struct tipc_msg *m)
	608	{
	609	return msg_bits(m, 5, 16, 0xffff);
	610	}
	611
	612	static inline void msg_set_session(struct tipc_msg *m, u32 n)
	613	{
	614	msg_set_bits(m, 5, 16, 0xffff, n);
	615	}
	616
	617	static inline u32 msg_probe(struct tipc_msg *m)
	618	{
	619	return msg_bits(m, 5, 0, 1);
	620	}
	621
	622	static inline void msg_set_probe(struct tipc_msg *m, u32 val)
	623	{
7eb878ed	624	msg_set_bits(m, 5, 0, 1, val);
b97bf3fd PL	625	}
	626
	627	static inline char msg_net_plane(struct tipc_msg *m)
	628	{
	629	return msg_bits(m, 5, 1, 7) + 'A';
	630	}
	631
	632	static inline void msg_set_net_plane(struct tipc_msg *m, char n)
	633	{
	634	msg_set_bits(m, 5, 1, 7, (n - 'A'));
	635	}
	636
	637	static inline u32 msg_linkprio(struct tipc_msg *m)
	638	{
	639	return msg_bits(m, 5, 4, 0x1f);
	640	}
	641
	642	static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
	643	{
	644	msg_set_bits(m, 5, 4, 0x1f, n);
	645	}
	646
	647	static inline u32 msg_bearer_id(struct tipc_msg *m)
	648	{
	649	return msg_bits(m, 5, 9, 0x7);
	650	}
	651
	652	static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
	653	{
	654	msg_set_bits(m, 5, 9, 0x7, n);
	655	}
	656
	657	static inline u32 msg_redundant_link(struct tipc_msg *m)
	658	{
	659	return msg_bits(m, 5, 12, 0x1);
	660	}
	661
77f167fc	662	static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
b97bf3fd	663	{
77f167fc	664	msg_set_bits(m, 5, 12, 0x1, r);
b97bf3fd PL	665	}
b97bf3fd PL	666
3d749a6a AS	667	static inline char msg_media_addr(struct tipc_msg m)
	668	{
	669	return (char *)&m->hdr[TIPC_MEDIA_ADDR_OFFSET];
	670	}
b97bf3fd	671
c4307285	672	/*
b97bf3fd PL	673	* Word 9
b97bf3fd PL	674	*/
b97bf3fd PL	675	static inline u32 msg_msgcnt(struct tipc_msg *m)
	676	{
	677	return msg_bits(m, 9, 16, 0xffff);
	678	}
	679
	680	static inline void msg_set_msgcnt(struct tipc_msg *m, u32 n)
	681	{
	682	msg_set_bits(m, 9, 16, 0xffff, n);
	683	}
	684
	685	static inline u32 msg_bcast_tag(struct tipc_msg *m)
	686	{
	687	return msg_bits(m, 9, 16, 0xffff);
	688	}
	689
	690	static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
	691	{
	692	msg_set_bits(m, 9, 16, 0xffff, n);
	693	}
	694
c4307285	695	static inline u32 msg_max_pkt(struct tipc_msg *m)
b97bf3fd	696	{
a02cec21	697	return msg_bits(m, 9, 16, 0xffff) * 4;
b97bf3fd PL	698	}
b97bf3fd PL	699
c4307285	700	static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
b97bf3fd PL	701	{
	702	msg_set_bits(m, 9, 16, 0xffff, (n / 4));
	703	}
	704
	705	static inline u32 msg_link_tolerance(struct tipc_msg *m)
	706	{
	707	return msg_bits(m, 9, 0, 0xffff);
	708	}
	709
	710	static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
	711	{
	712	msg_set_bits(m, 9, 0, 0xffff, n);
	713	}
	714
4f1688b2 JPM	715	static inline u32 tipc_msg_tot_importance(struct tipc_msg *m)
	716	{
	717	if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
	718	return msg_importance(msg_get_wrapped(m));
	719	return msg_importance(m);
	720	}
	721
	722	static inline u32 msg_tot_origport(struct tipc_msg *m)
	723	{
	724	if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
	725	return msg_origport(msg_get_wrapped(m));
	726	return msg_origport(m);
	727	}
	728
8db1bae3 JPM	729	bool tipc_msg_reverse(struct sk_buff buf, u32 dnode, int err);
8db1bae3 JPM	730
5a379074 JPM	731	int tipc_msg_eval(struct sk_buff buf, u32 dnode);
5a379074 JPM	732
ae8509c4 PG	733	void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize,
ae8509c4 PG	734	u32 destnode);
4f1688b2	735
1dd0bd2b JPM	736	struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
	737	uint data_sz, u32 dnode, u32 onode,
	738	u32 dport, u32 oport, int errcode);
	739
37e22164 JPM	740	int tipc_buf_append(struct sk_buff headbuf, struct sk_buff buf);
37e22164 JPM	741
4f1688b2 JPM	742	bool tipc_msg_bundle(struct sk_buff bbuf, struct sk_buff buf, u32 mtu);
	743
	744	bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode);
	745
9fbfb8b1 JPM	746	int tipc_msg_build(struct tipc_msg mhdr, struct iovec const iov,
9fbfb8b1 JPM	747	int offset, int dsz, int mtu , struct sk_buff **chain);
067608e9	748
078bec82 JPM	749	struct sk_buff tipc_msg_reassemble(struct sk_buff chain);
078bec82 JPM	750
b97bf3fd	751	#endif