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

/*
 * net/tipc/msg.h: Include file for TIPC message header routines
 *
 * Copyright (c) 2000-2007, 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

/*
 *  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

/*
 * 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);
}

u32 tipc_msg_tot_importance(struct tipc_msg *m);
void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize,
		   u32 destnode);
int tipc_msg_build(struct tipc_msg *hdr, struct iovec const *msg_sect,
		   unsigned int len, int max_size, struct sk_buff **buf);
#endif
Commit	Line	Data
b97bf3fd PL	1	/*
b97bf3fd PL	2	* net/tipc/msg.h: Include file for TIPC message header routines
c4307285	3	*
1f9eda7e	4	* Copyright (c) 2000-2007, 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
b97bf3fd	445
c4307285	446	/*
cc4c4353	447	* Connection management protocol message types
b97bf3fd	448	*/
b97bf3fd PL	449	#define CONN_PROBE 0
	450	#define CONN_PROBE_REPLY 1
	451	#define CONN_ACK 2
	452
c4307285	453	/*
cc4c4353	454	* Name distributor message types
b97bf3fd	455	*/
b97bf3fd PL	456	#define PUBLICATION 0
	457	#define WITHDRAWAL 1
	458
92138d1f AS	459	/*
	460	* Segmentation message types
	461	*/
92138d1f AS	462	#define FIRST_FRAGMENT 0
	463	#define FRAGMENT 1
	464	#define LAST_FRAGMENT 2
	465
	466	/*
	467	* Link management protocol message types
	468	*/
92138d1f AS	469	#define STATE_MSG 0
	470	#define RESET_MSG 1
	471	#define ACTIVATE_MSG 2
	472
	473	/*
	474	* Changeover tunnel message types
	475	*/
	476	#define DUPLICATE_MSG 0
	477	#define ORIGINAL_MSG 1
	478
	479	/*
	480	* Config protocol message types
	481	*/
92138d1f AS	482	#define DSC_REQ_MSG 0
	483	#define DSC_RESP_MSG 1
	484
b97bf3fd	485
c4307285	486	/*
b97bf3fd PL	487	* Word 1
b97bf3fd PL	488	*/
b97bf3fd PL	489	static inline u32 msg_seq_gap(struct tipc_msg *m)
b97bf3fd PL	490	{
bd784533	491	return msg_bits(m, 1, 16, 0x1fff);
b97bf3fd PL	492	}
	493
	494	static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
	495	{
bd784533	496	msg_set_bits(m, 1, 16, 0x1fff, n);
b97bf3fd PL	497	}
b97bf3fd PL	498
fc0eea69 AS	499	static inline u32 msg_node_sig(struct tipc_msg *m)
	500	{
	501	return msg_bits(m, 1, 0, 0xffff);
	502	}
	503
	504	static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
	505	{
	506	msg_set_bits(m, 1, 0, 0xffff, n);
	507	}
	508
b97bf3fd	509
c4307285	510	/*
b97bf3fd PL	511	* Word 2
b97bf3fd PL	512	*/
b97bf3fd PL	513	static inline u32 msg_dest_domain(struct tipc_msg *m)
	514	{
	515	return msg_word(m, 2);
	516	}
	517
c4307285	518	static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
b97bf3fd PL	519	{
	520	msg_set_word(m, 2, n);
	521	}
	522
	523	static inline u32 msg_bcgap_after(struct tipc_msg *m)
	524	{
	525	return msg_bits(m, 2, 16, 0xffff);
	526	}
	527
	528	static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
	529	{
	530	msg_set_bits(m, 2, 16, 0xffff, n);
	531	}
	532
	533	static inline u32 msg_bcgap_to(struct tipc_msg *m)
	534	{
	535	return msg_bits(m, 2, 0, 0xffff);
	536	}
	537
c4307285	538	static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
b97bf3fd PL	539	{
	540	msg_set_bits(m, 2, 0, 0xffff, n);
	541	}
	542
	543
c4307285	544	/*
b97bf3fd PL	545	* Word 4
b97bf3fd PL	546	*/
b97bf3fd PL	547	static inline u32 msg_last_bcast(struct tipc_msg *m)
	548	{
	549	return msg_bits(m, 4, 16, 0xffff);
	550	}
	551
	552	static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
	553	{
	554	msg_set_bits(m, 4, 16, 0xffff, n);
	555	}
	556
b97bf3fd PL	557	static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
	558	{
	559	msg_set_bits(m, 4, 16, 0xffff, n);
	560	}
	561
	562
	563	static inline u32 msg_next_sent(struct tipc_msg *m)
	564	{
	565	return msg_bits(m, 4, 0, 0xffff);
	566	}
	567
	568	static inline void msg_set_next_sent(struct tipc_msg *m, u32 n)
	569	{
	570	msg_set_bits(m, 4, 0, 0xffff, n);
	571	}
	572
b97bf3fd PL	573	static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
	574	{
	575	msg_set_bits(m, 4, 0, 0xffff, n);
	576	}
	577
	578	static inline u32 msg_bc_netid(struct tipc_msg *m)
	579	{
	580	return msg_word(m, 4);
	581	}
	582
	583	static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
	584	{
	585	msg_set_word(m, 4, id);
	586	}
	587
	588	static inline u32 msg_link_selector(struct tipc_msg *m)
	589	{
	590	return msg_bits(m, 4, 0, 1);
	591	}
	592
	593	static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
	594	{
7eb878ed	595	msg_set_bits(m, 4, 0, 1, n);
b97bf3fd PL	596	}
b97bf3fd PL	597
c4307285	598	/*
b97bf3fd PL	599	* Word 5
b97bf3fd PL	600	*/
b97bf3fd PL	601	static inline u32 msg_session(struct tipc_msg *m)
	602	{
	603	return msg_bits(m, 5, 16, 0xffff);
	604	}
	605
	606	static inline void msg_set_session(struct tipc_msg *m, u32 n)
	607	{
	608	msg_set_bits(m, 5, 16, 0xffff, n);
	609	}
	610
	611	static inline u32 msg_probe(struct tipc_msg *m)
	612	{
	613	return msg_bits(m, 5, 0, 1);
	614	}
	615
	616	static inline void msg_set_probe(struct tipc_msg *m, u32 val)
	617	{
7eb878ed	618	msg_set_bits(m, 5, 0, 1, val);
b97bf3fd PL	619	}
	620
	621	static inline char msg_net_plane(struct tipc_msg *m)
	622	{
	623	return msg_bits(m, 5, 1, 7) + 'A';
	624	}
	625
	626	static inline void msg_set_net_plane(struct tipc_msg *m, char n)
	627	{
	628	msg_set_bits(m, 5, 1, 7, (n - 'A'));
	629	}
	630
	631	static inline u32 msg_linkprio(struct tipc_msg *m)
	632	{
	633	return msg_bits(m, 5, 4, 0x1f);
	634	}
	635
	636	static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
	637	{
	638	msg_set_bits(m, 5, 4, 0x1f, n);
	639	}
	640
	641	static inline u32 msg_bearer_id(struct tipc_msg *m)
	642	{
	643	return msg_bits(m, 5, 9, 0x7);
	644	}
	645
	646	static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
	647	{
	648	msg_set_bits(m, 5, 9, 0x7, n);
	649	}
	650
	651	static inline u32 msg_redundant_link(struct tipc_msg *m)
	652	{
	653	return msg_bits(m, 5, 12, 0x1);
	654	}
	655
77f167fc	656	static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
b97bf3fd	657	{
77f167fc	658	msg_set_bits(m, 5, 12, 0x1, r);
b97bf3fd PL	659	}
b97bf3fd PL	660
3d749a6a AS	661	static inline char msg_media_addr(struct tipc_msg m)
	662	{
	663	return (char *)&m->hdr[TIPC_MEDIA_ADDR_OFFSET];
	664	}
b97bf3fd	665
c4307285	666	/*
b97bf3fd PL	667	* Word 9
b97bf3fd PL	668	*/
b97bf3fd PL	669	static inline u32 msg_msgcnt(struct tipc_msg *m)
	670	{
	671	return msg_bits(m, 9, 16, 0xffff);
	672	}
	673
	674	static inline void msg_set_msgcnt(struct tipc_msg *m, u32 n)
	675	{
	676	msg_set_bits(m, 9, 16, 0xffff, n);
	677	}
	678
	679	static inline u32 msg_bcast_tag(struct tipc_msg *m)
	680	{
	681	return msg_bits(m, 9, 16, 0xffff);
	682	}
	683
	684	static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
	685	{
	686	msg_set_bits(m, 9, 16, 0xffff, n);
	687	}
	688
c4307285	689	static inline u32 msg_max_pkt(struct tipc_msg *m)
b97bf3fd	690	{
a02cec21	691	return msg_bits(m, 9, 16, 0xffff) * 4;
b97bf3fd PL	692	}
b97bf3fd PL	693
c4307285	694	static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
b97bf3fd PL	695	{
	696	msg_set_bits(m, 9, 16, 0xffff, (n / 4));
	697	}
	698
	699	static inline u32 msg_link_tolerance(struct tipc_msg *m)
	700	{
	701	return msg_bits(m, 9, 0, 0xffff);
	702	}
	703
	704	static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
	705	{
	706	msg_set_bits(m, 9, 0, 0xffff, n);
	707	}
	708
23461e83	709	u32 tipc_msg_tot_importance(struct tipc_msg *m);
ae8509c4 PG	710	void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize,
ae8509c4 PG	711	u32 destnode);
26896904	712	int tipc_msg_build(struct tipc_msg hdr, struct iovec const msg_sect,
9446b87a	713	unsigned int len, int max_size, struct sk_buff **buf);
b97bf3fd	714	#endif