[deliverable/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 u32 msg_fragm_no(struct tipc_msg *m)
{
	return msg_bits(m, 4, 16, 0xffff);
}

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 u32 msg_long_msgno(struct tipc_msg *m)
{
	return msg_bits(m, 4, 0, 0xffff);
}

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,
		   u32 num_sect, unsigned int total_len,
			    int max_size, int usrmem, 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	*/
	47
b97bf3fd	48	#define TIPC_VERSION 2
06d82c91	49
d265fef6	50	/*
cc4c4353 AS	51	* Payload message users are defined in TIPC's public API:
	52	* - TIPC_LOW_IMPORTANCE
	53	* - TIPC_MEDIUM_IMPORTANCE
	54	* - TIPC_HIGH_IMPORTANCE
	55	* - TIPC_CRITICAL_IMPORTANCE
	56	*/
	57
	58	/*
	59	* Payload message types
d265fef6 AS	60	*/
	61
	62	#define TIPC_CONN_MSG 0
	63	#define TIPC_MCAST_MSG 1
	64	#define TIPC_NAMED_MSG 2
	65	#define TIPC_DIRECT_MSG 3
	66
cc4c4353 AS	67	/*
	68	* Message header sizes
	69	*/
d265fef6	70
741d9eb7 AS	71	#define SHORT_H_SIZE 24 /* In-cluster basic payload message */
	72	#define BASIC_H_SIZE 32 /* Basic payload message */
	73	#define NAMED_H_SIZE 40 /* Named payload message */
	74	#define MCAST_H_SIZE 44 /* Multicast payload message */
06d82c91 AS	75	#define INT_H_SIZE 40 /* Internal messages */
	76	#define MIN_H_SIZE 24 /* Smallest legal TIPC header size */
	77	#define MAX_H_SIZE 60 /* Largest possible TIPC header size */
	78
b97bf3fd	79	#define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
b97bf3fd	80
3d749a6a AS	81	#define TIPC_MEDIA_ADDR_OFFSET 5
3d749a6a AS	82
b97bf3fd	83
d265fef6 AS	84	struct tipc_msg {
	85	__be32 hdr[15];
	86	};
c4307285	87
b97bf3fd	88
d265fef6 AS	89	static inline u32 msg_word(struct tipc_msg *m, u32 pos)
	90	{
	91	return ntohl(m->hdr[pos]);
	92	}
b97bf3fd PL	93
	94	static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
	95	{
	96	m->hdr[w] = htonl(val);
	97	}
	98
d265fef6 AS	99	static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
	100	{
	101	return (msg_word(m, w) >> pos) & mask;
	102	}
	103
b97bf3fd PL	104	static inline void msg_set_bits(struct tipc_msg *m, u32 w,
	105	u32 pos, u32 mask, u32 val)
	106	{
1f9eda7e	107	val = (val & mask) << pos;
becf3da2 AV	108	mask = mask << pos;
	109	m->hdr[w] &= ~htonl(mask);
	110	m->hdr[w] \|= htonl(val);
b97bf3fd PL	111	}
b97bf3fd PL	112
40aecb1b AS	113	static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)
	114	{
	115	u32 temp = msg->hdr[a];
	116
	117	msg->hdr[a] = msg->hdr[b];
	118	msg->hdr[b] = temp;
	119	}
	120
c4307285	121	/*
b97bf3fd PL	122	* Word 0
	123	*/
	124
	125	static inline u32 msg_version(struct tipc_msg *m)
	126	{
	127	return msg_bits(m, 0, 29, 7);
	128	}
	129
c4307285	130	static inline void msg_set_version(struct tipc_msg *m)
b97bf3fd	131	{
37695420	132	msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
b97bf3fd PL	133	}
	134
	135	static inline u32 msg_user(struct tipc_msg *m)
	136	{
	137	return msg_bits(m, 0, 25, 0xf);
	138	}
	139
	140	static inline u32 msg_isdata(struct tipc_msg *m)
	141	{
a02cec21	142	return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
b97bf3fd PL	143	}
b97bf3fd PL	144
c4307285	145	static inline void msg_set_user(struct tipc_msg *m, u32 n)
b97bf3fd PL	146	{
	147	msg_set_bits(m, 0, 25, 0xf, n);
	148	}
	149
d265fef6 AS	150	static inline u32 msg_importance(struct tipc_msg *m)
	151	{
	152	return msg_bits(m, 0, 25, 0xf);
	153	}
	154
c4307285	155	static inline void msg_set_importance(struct tipc_msg *m, u32 i)
b97bf3fd PL	156	{
	157	msg_set_user(m, i);
	158	}
	159
d265fef6 AS	160	static inline u32 msg_hdr_sz(struct tipc_msg *m)
	161	{
	162	return msg_bits(m, 0, 21, 0xf) << 2;
	163	}
	164
0e65967e	165	static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
b97bf3fd PL	166	{
	167	msg_set_bits(m, 0, 21, 0xf, n>>2);
	168	}
	169
d265fef6 AS	170	static inline u32 msg_size(struct tipc_msg *m)
	171	{
	172	return msg_bits(m, 0, 0, 0x1ffff);
	173	}
	174
	175	static inline u32 msg_data_sz(struct tipc_msg *m)
	176	{
	177	return msg_size(m) - msg_hdr_sz(m);
	178	}
	179
c4307285	180	static inline int msg_non_seq(struct tipc_msg *m)
b97bf3fd PL	181	{
	182	return msg_bits(m, 0, 20, 1);
	183	}
	184
40aecb1b	185	static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
b97bf3fd	186	{
40aecb1b	187	msg_set_bits(m, 0, 20, 1, n);
b97bf3fd PL	188	}
b97bf3fd PL	189
c4307285	190	static inline int msg_dest_droppable(struct tipc_msg *m)
b97bf3fd PL	191	{
	192	return msg_bits(m, 0, 19, 1);
	193	}
	194
c4307285	195	static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
b97bf3fd PL	196	{
	197	msg_set_bits(m, 0, 19, 1, d);
	198	}
	199
c4307285	200	static inline int msg_src_droppable(struct tipc_msg *m)
b97bf3fd PL	201	{
	202	return msg_bits(m, 0, 18, 1);
	203	}
	204
c4307285	205	static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
b97bf3fd PL	206	{
	207	msg_set_bits(m, 0, 18, 1, d);
	208	}
	209
	210	static inline void msg_set_size(struct tipc_msg *m, u32 sz)
	211	{
	212	m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) \| sz);
	213	}
	214
	215
c4307285	216	/*
b97bf3fd PL	217	* Word 1
	218	*/
	219
d265fef6 AS	220	static inline u32 msg_type(struct tipc_msg *m)
	221	{
	222	return msg_bits(m, 1, 29, 0x7);
	223	}
	224
c4307285	225	static inline void msg_set_type(struct tipc_msg *m, u32 n)
b97bf3fd PL	226	{
	227	msg_set_bits(m, 1, 29, 0x7, n);
	228	}
	229
d265fef6 AS	230	static inline u32 msg_named(struct tipc_msg *m)
	231	{
	232	return msg_type(m) == TIPC_NAMED_MSG;
	233	}
	234
	235	static inline u32 msg_mcast(struct tipc_msg *m)
	236	{
	237	return msg_type(m) == TIPC_MCAST_MSG;
	238	}
	239
	240	static inline u32 msg_connected(struct tipc_msg *m)
	241	{
	242	return msg_type(m) == TIPC_CONN_MSG;
	243	}
	244
	245	static inline u32 msg_errcode(struct tipc_msg *m)
	246	{
	247	return msg_bits(m, 1, 25, 0xf);
	248	}
	249
c4307285	250	static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
b97bf3fd PL	251	{
	252	msg_set_bits(m, 1, 25, 0xf, err);
	253	}
	254
c4307285	255	static inline u32 msg_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	256	{
	257	return msg_bits(m, 1, 21, 0xf);
	258	}
	259
c4307285	260	static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	261	{
	262	msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
	263	}
	264
c4307285	265	static inline void msg_reset_reroute_cnt(struct tipc_msg *m)
b97bf3fd PL	266	{
	267	msg_set_bits(m, 1, 21, 0xf, 0);
	268	}
	269
	270	static inline u32 msg_lookup_scope(struct tipc_msg *m)
	271	{
	272	return msg_bits(m, 1, 19, 0x3);
	273	}
	274
c4307285	275	static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
b97bf3fd PL	276	{
	277	msg_set_bits(m, 1, 19, 0x3, n);
	278	}
	279
b97bf3fd PL	280	static inline u32 msg_bcast_ack(struct tipc_msg *m)
	281	{
	282	return msg_bits(m, 1, 0, 0xffff);
	283	}
	284
c4307285	285	static inline void msg_set_bcast_ack(struct tipc_msg *m, u32 n)
b97bf3fd PL	286	{
	287	msg_set_bits(m, 1, 0, 0xffff, n);
	288	}
	289
	290
c4307285	291	/*
b97bf3fd PL	292	* Word 2
	293	*/
	294
	295	static inline u32 msg_ack(struct tipc_msg *m)
	296	{
	297	return msg_bits(m, 2, 16, 0xffff);
	298	}
	299
c4307285	300	static inline void msg_set_ack(struct tipc_msg *m, u32 n)
b97bf3fd PL	301	{
	302	msg_set_bits(m, 2, 16, 0xffff, n);
	303	}
	304
	305	static inline u32 msg_seqno(struct tipc_msg *m)
	306	{
	307	return msg_bits(m, 2, 0, 0xffff);
	308	}
	309
c4307285	310	static inline void msg_set_seqno(struct tipc_msg *m, u32 n)
b97bf3fd PL	311	{
	312	msg_set_bits(m, 2, 0, 0xffff, n);
	313	}
	314
c4307285	315	/*
b97bf3fd PL	316	* Words 3-10
	317	*/
	318
	319
d265fef6 AS	320	static inline u32 msg_prevnode(struct tipc_msg *m)
	321	{
	322	return msg_word(m, 3);
	323	}
	324
c4307285	325	static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
b97bf3fd PL	326	{
	327	msg_set_word(m, 3, a);
	328	}
	329
d265fef6 AS	330	static inline u32 msg_origport(struct tipc_msg *m)
	331	{
	332	return msg_word(m, 4);
	333	}
	334
c4307285	335	static inline void msg_set_origport(struct tipc_msg *m, u32 p)
b97bf3fd PL	336	{
	337	msg_set_word(m, 4, p);
	338	}
	339
d265fef6 AS	340	static inline u32 msg_destport(struct tipc_msg *m)
	341	{
	342	return msg_word(m, 5);
	343	}
	344
c4307285	345	static inline void msg_set_destport(struct tipc_msg *m, u32 p)
b97bf3fd PL	346	{
	347	msg_set_word(m, 5, p);
	348	}
	349
d265fef6 AS	350	static inline u32 msg_mc_netid(struct tipc_msg *m)
	351	{
	352	return msg_word(m, 5);
	353	}
	354
c4307285	355	static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
b97bf3fd PL	356	{
	357	msg_set_word(m, 5, p);
	358	}
	359
d265fef6 AS	360	static inline int msg_short(struct tipc_msg *m)
d265fef6 AS	361	{
741d9eb7	362	return msg_hdr_sz(m) == SHORT_H_SIZE;
d265fef6 AS	363	}
	364
	365	static inline u32 msg_orignode(struct tipc_msg *m)
	366	{
	367	if (likely(msg_short(m)))
	368	return msg_prevnode(m);
	369	return msg_word(m, 6);
	370	}
	371
c4307285	372	static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
b97bf3fd PL	373	{
	374	msg_set_word(m, 6, a);
	375	}
	376
d265fef6 AS	377	static inline u32 msg_destnode(struct tipc_msg *m)
	378	{
	379	return msg_word(m, 7);
	380	}
	381
c4307285	382	static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
b97bf3fd PL	383	{
	384	msg_set_word(m, 7, a);
	385	}
	386
d265fef6 AS	387	static inline u32 msg_nametype(struct tipc_msg *m)
	388	{
	389	return msg_word(m, 8);
	390	}
	391
c4307285	392	static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
b97bf3fd PL	393	{
	394	msg_set_word(m, 8, n);
	395	}
	396
d265fef6 AS	397	static inline u32 msg_nameinst(struct tipc_msg *m)
	398	{
	399	return msg_word(m, 9);
	400	}
	401
	402	static inline u32 msg_namelower(struct tipc_msg *m)
	403	{
	404	return msg_nameinst(m);
	405	}
	406
c4307285	407	static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
b97bf3fd PL	408	{
	409	msg_set_word(m, 9, n);
	410	}
	411
c4307285	412	static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
b97bf3fd PL	413	{
	414	msg_set_namelower(m, n);
	415	}
	416
d265fef6 AS	417	static inline u32 msg_nameupper(struct tipc_msg *m)
	418	{
	419	return msg_word(m, 10);
	420	}
	421
c4307285	422	static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
b97bf3fd PL	423	{
	424	msg_set_word(m, 10, n);
	425	}
	426
d265fef6 AS	427	static inline unchar msg_data(struct tipc_msg m)
	428	{
	429	return ((unchar *)m) + msg_hdr_sz(m);
	430	}
	431
b97bf3fd PL	432	static inline struct tipc_msg msg_get_wrapped(struct tipc_msg m)
	433	{
	434	return (struct tipc_msg *)msg_data(m);
	435	}
	436
b97bf3fd PL	437
b97bf3fd PL	438	/*
cc4c4353 AS	439	* Constants and routines used to read and write TIPC internal message headers
cc4c4353 AS	440	*/
b97bf3fd	441
c4307285	442	/*
cc4c4353	443	* Internal message users
b97bf3fd PL	444	*/
	445
	446	#define BCAST_PROTOCOL 5
	447	#define MSG_BUNDLER 6
	448	#define LINK_PROTOCOL 7
	449	#define CONN_MANAGER 8
51a8e4de	450	#define ROUTE_DISTRIBUTOR 9 /* obsoleted */
b97bf3fd PL	451	#define CHANGEOVER_PROTOCOL 10
	452	#define NAME_DISTRIBUTOR 11
	453	#define MSG_FRAGMENTER 12
	454	#define LINK_CONFIG 13
b97bf3fd	455
c4307285	456	/*
cc4c4353	457	* Connection management protocol message types
b97bf3fd PL	458	*/
	459
	460	#define CONN_PROBE 0
	461	#define CONN_PROBE_REPLY 1
	462	#define CONN_ACK 2
	463
c4307285	464	/*
cc4c4353	465	* Name distributor message types
b97bf3fd PL	466	*/
	467
	468	#define PUBLICATION 0
	469	#define WITHDRAWAL 1
	470
92138d1f AS	471	/*
	472	* Segmentation message types
	473	*/
	474
	475	#define FIRST_FRAGMENT 0
	476	#define FRAGMENT 1
	477	#define LAST_FRAGMENT 2
	478
	479	/*
	480	* Link management protocol message types
	481	*/
	482
	483	#define STATE_MSG 0
	484	#define RESET_MSG 1
	485	#define ACTIVATE_MSG 2
	486
	487	/*
	488	* Changeover tunnel message types
	489	*/
	490	#define DUPLICATE_MSG 0
	491	#define ORIGINAL_MSG 1
	492
	493	/*
	494	* Config protocol message types
	495	*/
	496
	497	#define DSC_REQ_MSG 0
	498	#define DSC_RESP_MSG 1
	499
b97bf3fd	500
c4307285	501	/*
b97bf3fd PL	502	* Word 1
	503	*/
	504
	505	static inline u32 msg_seq_gap(struct tipc_msg *m)
	506	{
bd784533	507	return msg_bits(m, 1, 16, 0x1fff);
b97bf3fd PL	508	}
	509
	510	static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
	511	{
bd784533	512	msg_set_bits(m, 1, 16, 0x1fff, n);
b97bf3fd PL	513	}
b97bf3fd PL	514
fc0eea69 AS	515	static inline u32 msg_node_sig(struct tipc_msg *m)
	516	{
	517	return msg_bits(m, 1, 0, 0xffff);
	518	}
	519
	520	static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
	521	{
	522	msg_set_bits(m, 1, 0, 0xffff, n);
	523	}
	524
b97bf3fd	525
c4307285	526	/*
b97bf3fd PL	527	* Word 2
	528	*/
	529
	530	static inline u32 msg_dest_domain(struct tipc_msg *m)
	531	{
	532	return msg_word(m, 2);
	533	}
	534
c4307285	535	static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
b97bf3fd PL	536	{
	537	msg_set_word(m, 2, n);
	538	}
	539
	540	static inline u32 msg_bcgap_after(struct tipc_msg *m)
	541	{
	542	return msg_bits(m, 2, 16, 0xffff);
	543	}
	544
	545	static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
	546	{
	547	msg_set_bits(m, 2, 16, 0xffff, n);
	548	}
	549
	550	static inline u32 msg_bcgap_to(struct tipc_msg *m)
	551	{
	552	return msg_bits(m, 2, 0, 0xffff);
	553	}
	554
c4307285	555	static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
b97bf3fd PL	556	{
	557	msg_set_bits(m, 2, 0, 0xffff, n);
	558	}
	559
	560
c4307285	561	/*
b97bf3fd PL	562	* Word 4
	563	*/
	564
	565	static inline u32 msg_last_bcast(struct tipc_msg *m)
	566	{
	567	return msg_bits(m, 4, 16, 0xffff);
	568	}
	569
	570	static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
	571	{
	572	msg_set_bits(m, 4, 16, 0xffff, n);
	573	}
	574
	575
	576	static inline u32 msg_fragm_no(struct tipc_msg *m)
	577	{
	578	return msg_bits(m, 4, 16, 0xffff);
	579	}
	580
	581	static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
	582	{
	583	msg_set_bits(m, 4, 16, 0xffff, n);
	584	}
	585
	586
	587	static inline u32 msg_next_sent(struct tipc_msg *m)
	588	{
	589	return msg_bits(m, 4, 0, 0xffff);
	590	}
	591
	592	static inline void msg_set_next_sent(struct tipc_msg *m, u32 n)
	593	{
	594	msg_set_bits(m, 4, 0, 0xffff, n);
	595	}
	596
	597
	598	static inline u32 msg_long_msgno(struct tipc_msg *m)
	599	{
	600	return msg_bits(m, 4, 0, 0xffff);
	601	}
	602
	603	static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
	604	{
	605	msg_set_bits(m, 4, 0, 0xffff, n);
	606	}
	607
	608	static inline u32 msg_bc_netid(struct tipc_msg *m)
	609	{
	610	return msg_word(m, 4);
	611	}
	612
	613	static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
	614	{
	615	msg_set_word(m, 4, id);
	616	}
	617
	618	static inline u32 msg_link_selector(struct tipc_msg *m)
	619	{
	620	return msg_bits(m, 4, 0, 1);
	621	}
	622
	623	static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
	624	{
7eb878ed	625	msg_set_bits(m, 4, 0, 1, n);
b97bf3fd PL	626	}
b97bf3fd PL	627
c4307285	628	/*
b97bf3fd PL	629	* Word 5
	630	*/
	631
	632	static inline u32 msg_session(struct tipc_msg *m)
	633	{
	634	return msg_bits(m, 5, 16, 0xffff);
	635	}
	636
	637	static inline void msg_set_session(struct tipc_msg *m, u32 n)
	638	{
	639	msg_set_bits(m, 5, 16, 0xffff, n);
	640	}
	641
	642	static inline u32 msg_probe(struct tipc_msg *m)
	643	{
	644	return msg_bits(m, 5, 0, 1);
	645	}
	646
	647	static inline void msg_set_probe(struct tipc_msg *m, u32 val)
	648	{
7eb878ed	649	msg_set_bits(m, 5, 0, 1, val);
b97bf3fd PL	650	}
	651
	652	static inline char msg_net_plane(struct tipc_msg *m)
	653	{
	654	return msg_bits(m, 5, 1, 7) + 'A';
	655	}
	656
	657	static inline void msg_set_net_plane(struct tipc_msg *m, char n)
	658	{
	659	msg_set_bits(m, 5, 1, 7, (n - 'A'));
	660	}
	661
	662	static inline u32 msg_linkprio(struct tipc_msg *m)
	663	{
	664	return msg_bits(m, 5, 4, 0x1f);
	665	}
	666
	667	static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
	668	{
	669	msg_set_bits(m, 5, 4, 0x1f, n);
	670	}
	671
	672	static inline u32 msg_bearer_id(struct tipc_msg *m)
	673	{
	674	return msg_bits(m, 5, 9, 0x7);
	675	}
	676
	677	static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
	678	{
	679	msg_set_bits(m, 5, 9, 0x7, n);
	680	}
	681
	682	static inline u32 msg_redundant_link(struct tipc_msg *m)
	683	{
	684	return msg_bits(m, 5, 12, 0x1);
	685	}
	686
77f167fc	687	static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
b97bf3fd	688	{
77f167fc	689	msg_set_bits(m, 5, 12, 0x1, r);
b97bf3fd PL	690	}
b97bf3fd PL	691
3d749a6a AS	692	static inline char msg_media_addr(struct tipc_msg m)
	693	{
	694	return (char *)&m->hdr[TIPC_MEDIA_ADDR_OFFSET];
	695	}
b97bf3fd	696
c4307285	697	/*
b97bf3fd PL	698	* Word 9
	699	*/
	700
	701	static inline u32 msg_msgcnt(struct tipc_msg *m)
	702	{
	703	return msg_bits(m, 9, 16, 0xffff);
	704	}
	705
	706	static inline void msg_set_msgcnt(struct tipc_msg *m, u32 n)
	707	{
	708	msg_set_bits(m, 9, 16, 0xffff, n);
	709	}
	710
	711	static inline u32 msg_bcast_tag(struct tipc_msg *m)
	712	{
	713	return msg_bits(m, 9, 16, 0xffff);
	714	}
	715
	716	static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
	717	{
	718	msg_set_bits(m, 9, 16, 0xffff, n);
	719	}
	720
c4307285	721	static inline u32 msg_max_pkt(struct tipc_msg *m)
b97bf3fd	722	{
a02cec21	723	return msg_bits(m, 9, 16, 0xffff) * 4;
b97bf3fd PL	724	}
b97bf3fd PL	725
c4307285	726	static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
b97bf3fd PL	727	{
	728	msg_set_bits(m, 9, 16, 0xffff, (n / 4));
	729	}
	730
	731	static inline u32 msg_link_tolerance(struct tipc_msg *m)
	732	{
	733	return msg_bits(m, 9, 0, 0xffff);
	734	}
	735
	736	static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
	737	{
	738	msg_set_bits(m, 9, 0, 0xffff, n);
	739	}
	740
23461e83 AS	741	u32 tipc_msg_tot_importance(struct tipc_msg *m);
	742	void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type,
	743	u32 hsize, u32 destnode);
26896904 AS	744	int tipc_msg_build(struct tipc_msg hdr, struct iovec const msg_sect,
26896904 AS	745	u32 num_sect, unsigned int total_len,
0e65967e	746	int max_size, int usrmem, struct sk_buff **buf);
b97bf3fd	747
b97bf3fd	748	#endif