2006-01-02 21:04:38 +03:00
/*
* net / tipc / msg . h : Include file for TIPC message header routines
2007-02-09 17:25:21 +03:00
*
2007-04-25 01:51:55 +04:00
* Copyright ( c ) 2000 - 2007 , Ericsson AB
2011-01-25 21:33:31 +03:00
* Copyright ( c ) 2005 - 2008 , 2010 - 2011 , Wind River Systems
2006-01-02 21:04:38 +03:00
* All rights reserved .
*
2006-01-11 15:30:43 +03:00
* Redistribution and use in source and binary forms , with or without
2006-01-02 21:04:38 +03:00
* modification , are permitted provided that the following conditions are met :
*
2006-01-11 15:30:43 +03:00
* 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 .
2006-01-02 21:04:38 +03:00
*
2006-01-11 15:30:43 +03:00
* 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
2006-01-02 21:04:38 +03:00
* POSSIBILITY OF SUCH DAMAGE .
*/
# ifndef _TIPC_MSG_H
# define _TIPC_MSG_H
2010-11-30 15:00:53 +03:00
# include "bearer.h"
2006-01-02 21:04:38 +03:00
2011-04-08 18:50:52 +04:00
/*
* Constants and routines used to read and write TIPC payload message headers
*
* Note : Some items are also used with TIPC internal message headers
*/
2006-01-02 21:04:38 +03:00
# define TIPC_VERSION 2
2008-03-07 02:06:55 +03:00
2010-11-30 15:00:53 +03:00
/*
2011-04-08 18:50:52 +04:00
* 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
2010-11-30 15:00:53 +03:00
*/
# define TIPC_CONN_MSG 0
# define TIPC_MCAST_MSG 1
# define TIPC_NAMED_MSG 2
# define TIPC_DIRECT_MSG 3
2011-04-08 18:50:52 +04:00
/*
* Message header sizes
*/
2010-11-30 15:00:53 +03:00
2008-03-07 02:06:55 +03:00
# define SHORT_H_SIZE 24 /* Connected, in-cluster messages */
2006-01-02 21:04:38 +03:00
# define DIR_MSG_H_SIZE 32 /* Directly addressed messages */
2008-03-07 02:06:55 +03:00
# define LONG_H_SIZE 40 /* Named messages */
2006-01-02 21:04:38 +03:00
# define MCAST_H_SIZE 44 /* Multicast messages */
2008-03-07 02:06:55 +03:00
# 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 */
2006-01-02 21:04:38 +03:00
# define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
2010-11-30 15:00:53 +03:00
struct tipc_msg {
__be32 hdr [ 15 ] ;
} ;
2007-02-09 17:25:21 +03:00
2006-01-02 21:04:38 +03:00
2010-11-30 15:00:53 +03:00
static inline u32 msg_word ( struct tipc_msg * m , u32 pos )
{
return ntohl ( m - > hdr [ pos ] ) ;
}
2006-01-02 21:04:38 +03:00
static inline void msg_set_word ( struct tipc_msg * m , u32 w , u32 val )
{
m - > hdr [ w ] = htonl ( val ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_bits ( struct tipc_msg * m , u32 w , u32 pos , u32 mask )
{
return ( msg_word ( m , w ) > > pos ) & mask ;
}
2006-01-02 21:04:38 +03:00
static inline void msg_set_bits ( struct tipc_msg * m , u32 w ,
u32 pos , u32 mask , u32 val )
{
2007-04-25 01:51:55 +04:00
val = ( val & mask ) < < pos ;
2008-04-27 09:42:14 +04:00
mask = mask < < pos ;
m - > hdr [ w ] & = ~ htonl ( mask ) ;
m - > hdr [ w ] | = htonl ( val ) ;
2006-01-02 21:04:38 +03:00
}
2008-06-05 04:54:48 +04:00
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 ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Word 0
*/
static inline u32 msg_version ( struct tipc_msg * m )
{
return msg_bits ( m , 0 , 29 , 7 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_version ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
2008-03-07 02:07:42 +03:00
msg_set_bits ( m , 0 , 29 , 7 , TIPC_VERSION ) ;
2006-01-02 21:04:38 +03:00
}
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 )
{
2010-09-23 00:43:57 +04:00
return msg_user ( m ) < = TIPC_CRITICAL_IMPORTANCE ;
2006-01-02 21:04:38 +03:00
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_user ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 0 , 25 , 0xf , n ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_importance ( struct tipc_msg * m )
{
return msg_bits ( m , 0 , 25 , 0xf ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_importance ( struct tipc_msg * m , u32 i )
2006-01-02 21:04:38 +03:00
{
msg_set_user ( m , i ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_hdr_sz ( struct tipc_msg * m )
{
return msg_bits ( m , 0 , 21 , 0xf ) < < 2 ;
}
2010-12-31 21:59:32 +03:00
static inline void msg_set_hdr_sz ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 0 , 21 , 0xf , n > > 2 ) ;
}
2010-11-30 15:00:53 +03:00
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline int msg_non_seq ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
return msg_bits ( m , 0 , 20 , 1 ) ;
}
2008-06-05 04:54:48 +04:00
static inline void msg_set_non_seq ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
2008-06-05 04:54:48 +04:00
msg_set_bits ( m , 0 , 20 , 1 , n ) ;
2006-01-02 21:04:38 +03:00
}
2007-02-09 17:25:21 +03:00
static inline int msg_dest_droppable ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
return msg_bits ( m , 0 , 19 , 1 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_dest_droppable ( struct tipc_msg * m , u32 d )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 0 , 19 , 1 , d ) ;
}
2007-02-09 17:25:21 +03:00
static inline int msg_src_droppable ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
return msg_bits ( m , 0 , 18 , 1 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_src_droppable ( struct tipc_msg * m , u32 d )
2006-01-02 21:04:38 +03:00
{
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 ) ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Word 1
*/
2010-11-30 15:00:53 +03:00
static inline u32 msg_type ( struct tipc_msg * m )
{
return msg_bits ( m , 1 , 29 , 0x7 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_type ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 1 , 29 , 0x7 , n ) ;
}
2010-11-30 15:00:53 +03:00
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_errcode ( struct tipc_msg * m , u32 err )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 1 , 25 , 0xf , err ) ;
}
2007-02-09 17:25:21 +03:00
static inline u32 msg_reroute_cnt ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
return msg_bits ( m , 1 , 21 , 0xf ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_incr_reroute_cnt ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 1 , 21 , 0xf , msg_reroute_cnt ( m ) + 1 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_reset_reroute_cnt ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_lookup_scope ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_bcast_ack ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 1 , 0 , 0xffff , n ) ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Word 2
*/
static inline u32 msg_ack ( struct tipc_msg * m )
{
return msg_bits ( m , 2 , 16 , 0xffff ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_ack ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 2 , 16 , 0xffff , n ) ;
}
static inline u32 msg_seqno ( struct tipc_msg * m )
{
return msg_bits ( m , 2 , 0 , 0xffff ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_seqno ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 2 , 0 , 0xffff , n ) ;
}
2008-06-05 04:54:48 +04:00
/*
* TIPC may utilize the " link ack # " and " link seq # " fields of a short
* message header to hold the destination node for the message , since the
* normal " dest node " field isn ' t present . This cache is only referenced
* when required , so populating the cache of a longer message header is
* harmless ( as long as the header has the two link sequence fields present ) .
*
* Note : Host byte order is OK here , since the info never goes off - card .
*/
static inline u32 msg_destnode_cache ( struct tipc_msg * m )
{
return m - > hdr [ 2 ] ;
}
static inline void msg_set_destnode_cache ( struct tipc_msg * m , u32 dnode )
{
m - > hdr [ 2 ] = dnode ;
}
2006-01-02 21:04:38 +03:00
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Words 3 - 10
*/
2010-11-30 15:00:53 +03:00
static inline u32 msg_prevnode ( struct tipc_msg * m )
{
return msg_word ( m , 3 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_prevnode ( struct tipc_msg * m , u32 a )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 3 , a ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_origport ( struct tipc_msg * m )
{
return msg_word ( m , 4 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_origport ( struct tipc_msg * m , u32 p )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 4 , p ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_destport ( struct tipc_msg * m )
{
return msg_word ( m , 5 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_destport ( struct tipc_msg * m , u32 p )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 5 , p ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_mc_netid ( struct tipc_msg * m )
{
return msg_word ( m , 5 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_mc_netid ( struct tipc_msg * m , u32 p )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 5 , p ) ;
}
2010-11-30 15:00:53 +03:00
static inline int msg_short ( struct tipc_msg * m )
{
return msg_hdr_sz ( m ) = = 24 ;
}
static inline u32 msg_orignode ( struct tipc_msg * m )
{
if ( likely ( msg_short ( m ) ) )
return msg_prevnode ( m ) ;
return msg_word ( m , 6 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_orignode ( struct tipc_msg * m , u32 a )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 6 , a ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_destnode ( struct tipc_msg * m )
{
return msg_word ( m , 7 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_destnode ( struct tipc_msg * m , u32 a )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 7 , a ) ;
}
2007-02-09 17:25:21 +03:00
static inline int msg_is_dest ( struct tipc_msg * m , u32 d )
2006-01-02 21:04:38 +03:00
{
2010-09-23 00:43:57 +04:00
return msg_short ( m ) | | ( msg_destnode ( m ) = = d ) ;
2006-01-02 21:04:38 +03:00
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_nametype ( struct tipc_msg * m )
{
return msg_word ( m , 8 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_nametype ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 8 , n ) ;
}
2010-11-30 15:00:53 +03:00
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_namelower ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 9 , n ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_nameinst ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_namelower ( m , n ) ;
}
2010-11-30 15:00:53 +03:00
static inline u32 msg_nameupper ( struct tipc_msg * m )
{
return msg_word ( m , 10 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_nameupper ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_word ( m , 10 , n ) ;
}
2010-11-30 15:00:53 +03:00
static inline unchar * msg_data ( struct tipc_msg * m )
{
return ( ( unchar * ) m ) + msg_hdr_sz ( m ) ;
}
2006-01-02 21:04:38 +03:00
static inline struct tipc_msg * msg_get_wrapped ( struct tipc_msg * m )
{
return ( struct tipc_msg * ) msg_data ( m ) ;
}
/*
2011-04-08 18:50:52 +04:00
* Constants and routines used to read and write TIPC internal message headers
*/
2006-01-02 21:04:38 +03:00
2007-02-09 17:25:21 +03:00
/*
2011-04-08 18:50:52 +04:00
* Internal message users
2006-01-02 21:04:38 +03:00
*/
# define BCAST_PROTOCOL 5
# define MSG_BUNDLER 6
# define LINK_PROTOCOL 7
# define CONN_MANAGER 8
2010-12-31 21:59:18 +03:00
# define ROUTE_DISTRIBUTOR 9 /* obsoleted */
2006-01-02 21:04:38 +03:00
# define CHANGEOVER_PROTOCOL 10
# define NAME_DISTRIBUTOR 11
# define MSG_FRAGMENTER 12
# define LINK_CONFIG 13
2007-02-09 17:25:21 +03:00
/*
2011-04-08 18:50:52 +04:00
* Connection management protocol message types
2006-01-02 21:04:38 +03:00
*/
# define CONN_PROBE 0
# define CONN_PROBE_REPLY 1
# define CONN_ACK 2
2007-02-09 17:25:21 +03:00
/*
2011-04-08 18:50:52 +04:00
* Name distributor message types
2006-01-02 21:04:38 +03:00
*/
# define PUBLICATION 0
# define WITHDRAWAL 1
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Word 1
*/
static inline u32 msg_seq_gap ( struct tipc_msg * m )
{
2008-06-05 04:47:30 +04:00
return msg_bits ( m , 1 , 16 , 0x1fff ) ;
2006-01-02 21:04:38 +03:00
}
static inline void msg_set_seq_gap ( struct tipc_msg * m , u32 n )
{
2008-06-05 04:47:30 +04:00
msg_set_bits ( m , 1 , 16 , 0x1fff , n ) ;
2006-01-02 21:04:38 +03:00
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Word 2
*/
static inline u32 msg_dest_domain ( struct tipc_msg * m )
{
return msg_word ( m , 2 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_dest_domain ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_bcgap_to ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
msg_set_bits ( m , 2 , 0 , 0xffff , n ) ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* 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 & 1 ) ) ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* 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 & 1 ) ) ;
}
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 ) ;
}
2011-02-28 23:30:20 +03:00
static inline void msg_set_redundant_link ( struct tipc_msg * m , u32 r )
2006-01-02 21:04:38 +03:00
{
2011-02-28 23:30:20 +03:00
msg_set_bits ( m , 5 , 12 , 0x1 , r ) ;
2006-01-02 21:04:38 +03:00
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* 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 ) ;
}
2007-02-09 17:25:21 +03:00
static inline u32 msg_max_pkt ( struct tipc_msg * m )
2006-01-02 21:04:38 +03:00
{
2010-09-23 00:43:57 +04:00
return msg_bits ( m , 9 , 16 , 0xffff ) * 4 ;
2006-01-02 21:04:38 +03:00
}
2007-02-09 17:25:21 +03:00
static inline void msg_set_max_pkt ( struct tipc_msg * m , u32 n )
2006-01-02 21:04:38 +03:00
{
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 ) ;
}
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Segmentation message types
*/
# define FIRST_FRAGMENT 0
# define FRAGMENT 1
# define LAST_FRAGMENT 2
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Link management protocol message types
*/
# define STATE_MSG 0
# define RESET_MSG 1
# define ACTIVATE_MSG 2
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Changeover tunnel message types
*/
# define DUPLICATE_MSG 0
# define ORIGINAL_MSG 1
2007-02-09 17:25:21 +03:00
/*
2006-01-02 21:04:38 +03:00
* Config protocol message types
*/
# define DSC_REQ_MSG 0
# define DSC_RESP_MSG 1
2010-05-11 18:30:18 +04:00
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_calc_data_size ( struct iovec const * msg_sect , u32 num_sect ) ;
int tipc_msg_build ( struct tipc_msg * hdr ,
2006-01-02 21:04:38 +03:00
struct iovec const * msg_sect , u32 num_sect ,
2010-12-31 21:59:32 +03:00
int max_size , int usrmem , struct sk_buff * * buf ) ;
2006-01-02 21:04:38 +03:00
2006-01-18 02:38:21 +03:00
static inline void msg_set_media_addr ( struct tipc_msg * m , struct tipc_media_addr * a )
{
memcpy ( & ( ( int * ) m ) [ 5 ] , a , sizeof ( * a ) ) ;
}
2006-01-02 21:04:38 +03:00
2006-01-18 02:38:21 +03:00
static inline void msg_get_media_addr ( struct tipc_msg * m , struct tipc_media_addr * a )
{
2010-12-31 21:59:32 +03:00
memcpy ( a , & ( ( int * ) m ) [ 5 ] , sizeof ( * a ) ) ;
2006-01-18 02:38:21 +03:00
}
2006-01-02 21:04:38 +03:00
# endif