1/* 2 * net/tipc/msg.h: Include file for TIPC message header routines 3 * 4 * Copyright (c) 2000-2007, 2014-2017 Ericsson AB 5 * Copyright (c) 2005-2008, 2010-2011, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 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. 19 * 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 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37#ifndef _TIPC_MSG_H 38#define _TIPC_MSG_H 39 40#include <linux/tipc.h> 41#include "core.h" 42 43/* 44 * Constants and routines used to read and write TIPC payload message headers 45 * 46 * Note: Some items are also used with TIPC internal message headers 47 */ 48#define TIPC_VERSION 2 49struct plist; 50 51/* 52 * Payload message users are defined in TIPC's public API: 53 * - TIPC_LOW_IMPORTANCE 54 * - TIPC_MEDIUM_IMPORTANCE 55 * - TIPC_HIGH_IMPORTANCE 56 * - TIPC_CRITICAL_IMPORTANCE 57 */ 58#define TIPC_SYSTEM_IMPORTANCE 4 59 60 61/* 62 * Payload message types 63 */ 64#define TIPC_CONN_MSG 0 65#define TIPC_MCAST_MSG 1 66#define TIPC_NAMED_MSG 2 67#define TIPC_DIRECT_MSG 3 68#define TIPC_GRP_MEMBER_EVT 4 69#define TIPC_GRP_BCAST_MSG 5 70#define TIPC_GRP_MCAST_MSG 6 71#define TIPC_GRP_UCAST_MSG 7 72 73/* 74 * Internal message users 75 */ 76#define BCAST_PROTOCOL 5 77#define MSG_BUNDLER 6 78#define LINK_PROTOCOL 7 79#define CONN_MANAGER 8 80#define GROUP_PROTOCOL 9 81#define TUNNEL_PROTOCOL 10 82#define NAME_DISTRIBUTOR 11 83#define MSG_FRAGMENTER 12 84#define LINK_CONFIG 13 85#define MSG_CRYPTO 14 86#define SOCK_WAKEUP 14 /* pseudo user */ 87#define TOP_SRV 15 /* pseudo user */ 88 89/* 90 * Message header sizes 91 */ 92#define SHORT_H_SIZE 24 /* In-cluster basic payload message */ 93#define BASIC_H_SIZE 32 /* Basic payload message */ 94#define NAMED_H_SIZE 40 /* Named payload message */ 95#define MCAST_H_SIZE 44 /* Multicast payload message */ 96#define GROUP_H_SIZE 44 /* Group payload message */ 97#define INT_H_SIZE 40 /* Internal messages */ 98#define MIN_H_SIZE 24 /* Smallest legal TIPC header size */ 99#define MAX_H_SIZE 60 /* Largest possible TIPC header size */ 100 101#define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE) 102#define TIPC_MEDIA_INFO_OFFSET 5 103 104extern const int one_page_mtu; 105 106struct tipc_skb_cb { 107 union { 108 struct { 109 struct sk_buff *tail; 110 unsigned long nxt_retr; 111 unsigned long retr_stamp; 112 u32 bytes_read; 113 u32 orig_member; 114 u16 chain_imp; 115 u16 ackers; 116 u16 retr_cnt; 117 } __packed; 118#ifdef CONFIG_TIPC_CRYPTO 119 struct { 120 struct tipc_crypto *rx; 121 struct tipc_aead *last; 122 u8 recurs; 123 } tx_clone_ctx __packed; 124#endif 125 } __packed; 126 union { 127 struct { 128 u8 validated:1; 129#ifdef CONFIG_TIPC_CRYPTO 130 u8 encrypted:1; 131 u8 decrypted:1; 132#define SKB_PROBING 1 133#define SKB_GRACING 2 134 u8 xmit_type:2; 135 u8 tx_clone_deferred:1; 136#endif 137 }; 138 u8 flags; 139 }; 140 u8 reserved; 141#ifdef CONFIG_TIPC_CRYPTO 142 void *crypto_ctx; 143#endif 144} __packed; 145 146#define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0])) 147 148struct tipc_msg { 149 __be32 hdr[15]; 150}; 151 152/* struct tipc_gap_ack - TIPC Gap ACK block 153 * @ack: seqno of the last consecutive packet in link deferdq 154 * @gap: number of gap packets since the last ack 155 * 156 * E.g: 157 * link deferdq: 1 2 3 4 10 11 13 14 15 20 158 * --> Gap ACK blocks: <4, 5>, <11, 1>, <15, 4>, <20, 0> 159 */ 160struct tipc_gap_ack { 161 __be16 ack; 162 __be16 gap; 163}; 164 165/* struct tipc_gap_ack_blks 166 * @len: actual length of the record 167 * @ugack_cnt: number of Gap ACK blocks for unicast (following the broadcast 168 * ones) 169 * @start_index: starting index for "valid" broadcast Gap ACK blocks 170 * @bgack_cnt: number of Gap ACK blocks for broadcast in the record 171 * @gacks: array of Gap ACK blocks 172 * 173 * 31 16 15 0 174 * +-------------+-------------+-------------+-------------+ 175 * | bgack_cnt | ugack_cnt | len | 176 * +-------------+-------------+-------------+-------------+ - 177 * | gap | ack | | 178 * +-------------+-------------+-------------+-------------+ > bc gacks 179 * : : : | 180 * +-------------+-------------+-------------+-------------+ - 181 * | gap | ack | | 182 * +-------------+-------------+-------------+-------------+ > uc gacks 183 * : : : | 184 * +-------------+-------------+-------------+-------------+ - 185 */ 186struct tipc_gap_ack_blks { 187 __be16 len; 188 union { 189 u8 ugack_cnt; 190 u8 start_index; 191 }; 192 u8 bgack_cnt; 193 struct tipc_gap_ack gacks[]; 194}; 195 196#define MAX_GAP_ACK_BLKS 128 197#define MAX_GAP_ACK_BLKS_SZ (sizeof(struct tipc_gap_ack_blks) + \ 198 sizeof(struct tipc_gap_ack) * MAX_GAP_ACK_BLKS) 199 200static inline struct tipc_msg *buf_msg(struct sk_buff *skb) 201{ 202 return (struct tipc_msg *)skb->data; 203} 204 205static inline u32 msg_word(struct tipc_msg *m, u32 pos) 206{ 207 return ntohl(m->hdr[pos]); 208} 209 210static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val) 211{ 212 m->hdr[w] = htonl(val); 213} 214 215static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask) 216{ 217 return (msg_word(m, w) >> pos) & mask; 218} 219 220static inline void msg_set_bits(struct tipc_msg *m, u32 w, 221 u32 pos, u32 mask, u32 val) 222{ 223 val = (val & mask) << pos; 224 mask = mask << pos; 225 m->hdr[w] &= ~htonl(mask); 226 m->hdr[w] |= htonl(val); 227} 228 229static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b) 230{ 231 u32 temp = msg->hdr[a]; 232 233 msg->hdr[a] = msg->hdr[b]; 234 msg->hdr[b] = temp; 235} 236 237/* 238 * Word 0 239 */ 240static inline u32 msg_version(struct tipc_msg *m) 241{ 242 return msg_bits(m, 0, 29, 7); 243} 244 245static inline void msg_set_version(struct tipc_msg *m) 246{ 247 msg_set_bits(m, 0, 29, 7, TIPC_VERSION); 248} 249 250static inline u32 msg_user(struct tipc_msg *m) 251{ 252 return msg_bits(m, 0, 25, 0xf); 253} 254 255static inline u32 msg_isdata(struct tipc_msg *m) 256{ 257 return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE; 258} 259 260static inline void msg_set_user(struct tipc_msg *m, u32 n) 261{ 262 msg_set_bits(m, 0, 25, 0xf, n); 263} 264 265static inline u32 msg_hdr_sz(struct tipc_msg *m) 266{ 267 return msg_bits(m, 0, 21, 0xf) << 2; 268} 269 270static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n) 271{ 272 msg_set_bits(m, 0, 21, 0xf, n>>2); 273} 274 275static inline u32 msg_size(struct tipc_msg *m) 276{ 277 return msg_bits(m, 0, 0, 0x1ffff); 278} 279 280static inline u32 msg_blocks(struct tipc_msg *m) 281{ 282 return (msg_size(m) / 1024) + 1; 283} 284 285static inline u32 msg_data_sz(struct tipc_msg *m) 286{ 287 return msg_size(m) - msg_hdr_sz(m); 288} 289 290static inline int msg_non_seq(struct tipc_msg *m) 291{ 292 return msg_bits(m, 0, 20, 1); 293} 294 295static inline void msg_set_non_seq(struct tipc_msg *m, u32 n) 296{ 297 msg_set_bits(m, 0, 20, 1, n); 298} 299 300static inline int msg_is_syn(struct tipc_msg *m) 301{ 302 return msg_bits(m, 0, 17, 1); 303} 304 305static inline void msg_set_syn(struct tipc_msg *m, u32 d) 306{ 307 msg_set_bits(m, 0, 17, 1, d); 308} 309 310static inline int msg_dest_droppable(struct tipc_msg *m) 311{ 312 return msg_bits(m, 0, 19, 1); 313} 314 315static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d) 316{ 317 msg_set_bits(m, 0, 19, 1, d); 318} 319 320static inline int msg_is_keepalive(struct tipc_msg *m) 321{ 322 return msg_bits(m, 0, 19, 1); 323} 324 325static inline void msg_set_is_keepalive(struct tipc_msg *m, u32 d) 326{ 327 msg_set_bits(m, 0, 19, 1, d); 328} 329 330static inline int msg_src_droppable(struct tipc_msg *m) 331{ 332 return msg_bits(m, 0, 18, 1); 333} 334 335static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d) 336{ 337 msg_set_bits(m, 0, 18, 1, d); 338} 339 340static inline int msg_ack_required(struct tipc_msg *m) 341{ 342 return msg_bits(m, 0, 18, 1); 343} 344 345static inline void msg_set_ack_required(struct tipc_msg *m) 346{ 347 msg_set_bits(m, 0, 18, 1, 1); 348} 349 350static inline int msg_nagle_ack(struct tipc_msg *m) 351{ 352 return msg_bits(m, 0, 18, 1); 353} 354 355static inline void msg_set_nagle_ack(struct tipc_msg *m) 356{ 357 msg_set_bits(m, 0, 18, 1, 1); 358} 359 360static inline bool msg_is_rcast(struct tipc_msg *m) 361{ 362 return msg_bits(m, 0, 18, 0x1); 363} 364 365static inline void msg_set_is_rcast(struct tipc_msg *m, bool d) 366{ 367 msg_set_bits(m, 0, 18, 0x1, d); 368} 369 370static inline void msg_set_size(struct tipc_msg *m, u32 sz) 371{ 372 m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz); 373} 374 375static inline unchar *msg_data(struct tipc_msg *m) 376{ 377 return ((unchar *)m) + msg_hdr_sz(m); 378} 379 380static inline struct tipc_msg *msg_inner_hdr(struct tipc_msg *m) 381{ 382 return (struct tipc_msg *)msg_data(m); 383} 384 385/* 386 * Word 1 387 */ 388static inline u32 msg_type(struct tipc_msg *m) 389{ 390 return msg_bits(m, 1, 29, 0x7); 391} 392 393static inline void msg_set_type(struct tipc_msg *m, u32 n) 394{ 395 msg_set_bits(m, 1, 29, 0x7, n); 396} 397 398static inline int msg_in_group(struct tipc_msg *m) 399{ 400 int mtyp = msg_type(m); 401 402 return mtyp >= TIPC_GRP_MEMBER_EVT && mtyp <= TIPC_GRP_UCAST_MSG; 403} 404 405static inline bool msg_is_grp_evt(struct tipc_msg *m) 406{ 407 return msg_type(m) == TIPC_GRP_MEMBER_EVT; 408} 409 410static inline u32 msg_named(struct tipc_msg *m) 411{ 412 return msg_type(m) == TIPC_NAMED_MSG; 413} 414 415static inline u32 msg_mcast(struct tipc_msg *m) 416{ 417 int mtyp = msg_type(m); 418 419 return ((mtyp == TIPC_MCAST_MSG) || (mtyp == TIPC_GRP_BCAST_MSG) || 420 (mtyp == TIPC_GRP_MCAST_MSG)); 421} 422 423static inline u32 msg_connected(struct tipc_msg *m) 424{ 425 return msg_type(m) == TIPC_CONN_MSG; 426} 427 428static inline u32 msg_direct(struct tipc_msg *m) 429{ 430 return msg_type(m) == TIPC_DIRECT_MSG; 431} 432 433static inline u32 msg_errcode(struct tipc_msg *m) 434{ 435 return msg_bits(m, 1, 25, 0xf); 436} 437 438static inline void msg_set_errcode(struct tipc_msg *m, u32 err) 439{ 440 msg_set_bits(m, 1, 25, 0xf, err); 441} 442 443static inline void msg_set_bulk(struct tipc_msg *m) 444{ 445 msg_set_bits(m, 1, 28, 0x1, 1); 446} 447 448static inline u32 msg_is_bulk(struct tipc_msg *m) 449{ 450 return msg_bits(m, 1, 28, 0x1); 451} 452 453static inline void msg_set_last_bulk(struct tipc_msg *m) 454{ 455 msg_set_bits(m, 1, 27, 0x1, 1); 456} 457 458static inline u32 msg_is_last_bulk(struct tipc_msg *m) 459{ 460 return msg_bits(m, 1, 27, 0x1); 461} 462 463static inline void msg_set_non_legacy(struct tipc_msg *m) 464{ 465 msg_set_bits(m, 1, 26, 0x1, 1); 466} 467 468static inline u32 msg_is_legacy(struct tipc_msg *m) 469{ 470 return !msg_bits(m, 1, 26, 0x1); 471} 472 473static inline u32 msg_reroute_cnt(struct tipc_msg *m) 474{ 475 return msg_bits(m, 1, 21, 0xf); 476} 477 478static inline void msg_incr_reroute_cnt(struct tipc_msg *m) 479{ 480 msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1); 481} 482 483static inline void msg_reset_reroute_cnt(struct tipc_msg *m) 484{ 485 msg_set_bits(m, 1, 21, 0xf, 0); 486} 487 488static inline u32 msg_lookup_scope(struct tipc_msg *m) 489{ 490 return msg_bits(m, 1, 19, 0x3); 491} 492 493static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n) 494{ 495 msg_set_bits(m, 1, 19, 0x3, n); 496} 497 498static inline u16 msg_bcast_ack(struct tipc_msg *m) 499{ 500 return msg_bits(m, 1, 0, 0xffff); 501} 502 503static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n) 504{ 505 msg_set_bits(m, 1, 0, 0xffff, n); 506} 507 508/* Note: reusing bits in word 1 for ACTIVATE_MSG only, to re-synch 509 * link peer session number 510 */ 511static inline bool msg_dest_session_valid(struct tipc_msg *m) 512{ 513 return msg_bits(m, 1, 16, 0x1); 514} 515 516static inline void msg_set_dest_session_valid(struct tipc_msg *m, bool valid) 517{ 518 msg_set_bits(m, 1, 16, 0x1, valid); 519} 520 521static inline u16 msg_dest_session(struct tipc_msg *m) 522{ 523 return msg_bits(m, 1, 0, 0xffff); 524} 525 526static inline void msg_set_dest_session(struct tipc_msg *m, u16 n) 527{ 528 msg_set_bits(m, 1, 0, 0xffff, n); 529} 530 531/* 532 * Word 2 533 */ 534static inline u16 msg_ack(struct tipc_msg *m) 535{ 536 return msg_bits(m, 2, 16, 0xffff); 537} 538 539static inline void msg_set_ack(struct tipc_msg *m, u16 n) 540{ 541 msg_set_bits(m, 2, 16, 0xffff, n); 542} 543 544static inline u16 msg_seqno(struct tipc_msg *m) 545{ 546 return msg_bits(m, 2, 0, 0xffff); 547} 548 549static inline void msg_set_seqno(struct tipc_msg *m, u16 n) 550{ 551 msg_set_bits(m, 2, 0, 0xffff, n); 552} 553 554/* 555 * Words 3-10 556 */ 557static inline u32 msg_importance(struct tipc_msg *m) 558{ 559 int usr = msg_user(m); 560 561 if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m))) 562 return usr; 563 if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)) 564 return msg_bits(m, 9, 0, 0x7); 565 return TIPC_SYSTEM_IMPORTANCE; 566} 567 568static inline void msg_set_importance(struct tipc_msg *m, u32 i) 569{ 570 int usr = msg_user(m); 571 572 if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))) 573 msg_set_bits(m, 9, 0, 0x7, i); 574 else if (i < TIPC_SYSTEM_IMPORTANCE) 575 msg_set_user(m, i); 576 else 577 pr_warn("Trying to set illegal importance in message\n"); 578} 579 580static inline u32 msg_prevnode(struct tipc_msg *m) 581{ 582 return msg_word(m, 3); 583} 584 585static inline void msg_set_prevnode(struct tipc_msg *m, u32 a) 586{ 587 msg_set_word(m, 3, a); 588} 589 590static inline u32 msg_origport(struct tipc_msg *m) 591{ 592 if (msg_user(m) == MSG_FRAGMENTER) 593 m = msg_inner_hdr(m); 594 return msg_word(m, 4); 595} 596 597static inline void msg_set_origport(struct tipc_msg *m, u32 p) 598{ 599 msg_set_word(m, 4, p); 600} 601 602static inline u16 msg_named_seqno(struct tipc_msg *m) 603{ 604 return msg_bits(m, 4, 0, 0xffff); 605} 606 607static inline void msg_set_named_seqno(struct tipc_msg *m, u16 n) 608{ 609 msg_set_bits(m, 4, 0, 0xffff, n); 610} 611 612static inline u32 msg_destport(struct tipc_msg *m) 613{ 614 return msg_word(m, 5); 615} 616 617static inline void msg_set_destport(struct tipc_msg *m, u32 p) 618{ 619 msg_set_word(m, 5, p); 620} 621 622static inline u32 msg_mc_netid(struct tipc_msg *m) 623{ 624 return msg_word(m, 5); 625} 626 627static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p) 628{ 629 msg_set_word(m, 5, p); 630} 631 632static inline int msg_short(struct tipc_msg *m) 633{ 634 return msg_hdr_sz(m) == SHORT_H_SIZE; 635} 636 637static inline u32 msg_orignode(struct tipc_msg *m) 638{ 639 if (likely(msg_short(m))) 640 return msg_prevnode(m); 641 return msg_word(m, 6); 642} 643 644static inline void msg_set_orignode(struct tipc_msg *m, u32 a) 645{ 646 msg_set_word(m, 6, a); 647} 648 649static inline u32 msg_destnode(struct tipc_msg *m) 650{ 651 return msg_word(m, 7); 652} 653 654static inline void msg_set_destnode(struct tipc_msg *m, u32 a) 655{ 656 msg_set_word(m, 7, a); 657} 658 659static inline u32 msg_nametype(struct tipc_msg *m) 660{ 661 return msg_word(m, 8); 662} 663 664static inline void msg_set_nametype(struct tipc_msg *m, u32 n) 665{ 666 msg_set_word(m, 8, n); 667} 668 669static inline u32 msg_nameinst(struct tipc_msg *m) 670{ 671 return msg_word(m, 9); 672} 673 674static inline u32 msg_namelower(struct tipc_msg *m) 675{ 676 return msg_nameinst(m); 677} 678 679static inline void msg_set_namelower(struct tipc_msg *m, u32 n) 680{ 681 msg_set_word(m, 9, n); 682} 683 684static inline void msg_set_nameinst(struct tipc_msg *m, u32 n) 685{ 686 msg_set_namelower(m, n); 687} 688 689static inline u32 msg_nameupper(struct tipc_msg *m) 690{ 691 return msg_word(m, 10); 692} 693 694static inline void msg_set_nameupper(struct tipc_msg *m, u32 n) 695{ 696 msg_set_word(m, 10, n); 697} 698 699/* 700 * Constants and routines used to read and write TIPC internal message headers 701 */ 702 703/* 704 * Connection management protocol message types 705 */ 706#define CONN_PROBE 0 707#define CONN_PROBE_REPLY 1 708#define CONN_ACK 2 709 710/* 711 * Name distributor message types 712 */ 713#define PUBLICATION 0 714#define WITHDRAWAL 1 715 716/* 717 * Segmentation message types 718 */ 719#define FIRST_FRAGMENT 0 720#define FRAGMENT 1 721#define LAST_FRAGMENT 2 722 723/* 724 * Link management protocol message types 725 */ 726#define STATE_MSG 0 727#define RESET_MSG 1 728#define ACTIVATE_MSG 2 729 730/* 731 * Changeover tunnel message types 732 */ 733#define SYNCH_MSG 0 734#define FAILOVER_MSG 1 735 736/* 737 * Config protocol message types 738 */ 739#define DSC_REQ_MSG 0 740#define DSC_RESP_MSG 1 741#define DSC_TRIAL_MSG 2 742#define DSC_TRIAL_FAIL_MSG 3 743 744/* 745 * Group protocol message types 746 */ 747#define GRP_JOIN_MSG 0 748#define GRP_LEAVE_MSG 1 749#define GRP_ADV_MSG 2 750#define GRP_ACK_MSG 3 751#define GRP_RECLAIM_MSG 4 752#define GRP_REMIT_MSG 5 753 754/* Crypto message types */ 755#define KEY_DISTR_MSG 0 756 757/* 758 * Word 1 759 */ 760static inline u32 msg_seq_gap(struct tipc_msg *m) 761{ 762 return msg_bits(m, 1, 16, 0x1fff); 763} 764 765static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n) 766{ 767 msg_set_bits(m, 1, 16, 0x1fff, n); 768} 769 770static inline u32 msg_node_sig(struct tipc_msg *m) 771{ 772 return msg_bits(m, 1, 0, 0xffff); 773} 774 775static inline void msg_set_node_sig(struct tipc_msg *m, u32 n) 776{ 777 msg_set_bits(m, 1, 0, 0xffff, n); 778} 779 780static inline u32 msg_node_capabilities(struct tipc_msg *m) 781{ 782 return msg_bits(m, 1, 15, 0x1fff); 783} 784 785static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n) 786{ 787 msg_set_bits(m, 1, 15, 0x1fff, n); 788} 789 790/* 791 * Word 2 792 */ 793static inline u32 msg_dest_domain(struct tipc_msg *m) 794{ 795 return msg_word(m, 2); 796} 797 798static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n) 799{ 800 msg_set_word(m, 2, n); 801} 802 803static inline u32 msg_bcgap_after(struct tipc_msg *m) 804{ 805 return msg_bits(m, 2, 16, 0xffff); 806} 807 808static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n) 809{ 810 msg_set_bits(m, 2, 16, 0xffff, n); 811} 812 813static inline u32 msg_bcgap_to(struct tipc_msg *m) 814{ 815 return msg_bits(m, 2, 0, 0xffff); 816} 817 818static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n) 819{ 820 msg_set_bits(m, 2, 0, 0xffff, n); 821} 822 823/* 824 * Word 4 825 */ 826static inline u32 msg_last_bcast(struct tipc_msg *m) 827{ 828 return msg_bits(m, 4, 16, 0xffff); 829} 830 831static inline u32 msg_bc_snd_nxt(struct tipc_msg *m) 832{ 833 return msg_last_bcast(m) + 1; 834} 835 836static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n) 837{ 838 msg_set_bits(m, 4, 16, 0xffff, n); 839} 840 841static inline u32 msg_nof_fragms(struct tipc_msg *m) 842{ 843 return msg_bits(m, 4, 0, 0xffff); 844} 845 846static inline void msg_set_nof_fragms(struct tipc_msg *m, u32 n) 847{ 848 msg_set_bits(m, 4, 0, 0xffff, n); 849} 850 851static inline u32 msg_fragm_no(struct tipc_msg *m) 852{ 853 return msg_bits(m, 4, 16, 0xffff); 854} 855 856static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n) 857{ 858 msg_set_bits(m, 4, 16, 0xffff, n); 859} 860 861static inline u16 msg_next_sent(struct tipc_msg *m) 862{ 863 return msg_bits(m, 4, 0, 0xffff); 864} 865 866static inline void msg_set_next_sent(struct tipc_msg *m, u16 n) 867{ 868 msg_set_bits(m, 4, 0, 0xffff, n); 869} 870 871static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n) 872{ 873 msg_set_bits(m, 4, 0, 0xffff, n); 874} 875 876static inline u32 msg_bc_netid(struct tipc_msg *m) 877{ 878 return msg_word(m, 4); 879} 880 881static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id) 882{ 883 msg_set_word(m, 4, id); 884} 885 886static inline u32 msg_link_selector(struct tipc_msg *m) 887{ 888 if (msg_user(m) == MSG_FRAGMENTER) 889 m = (void *)msg_data(m); 890 return msg_bits(m, 4, 0, 1); 891} 892 893/* 894 * Word 5 895 */ 896static inline u16 msg_session(struct tipc_msg *m) 897{ 898 return msg_bits(m, 5, 16, 0xffff); 899} 900 901static inline void msg_set_session(struct tipc_msg *m, u16 n) 902{ 903 msg_set_bits(m, 5, 16, 0xffff, n); 904} 905 906static inline u32 msg_probe(struct tipc_msg *m) 907{ 908 return msg_bits(m, 5, 0, 1); 909} 910 911static inline void msg_set_probe(struct tipc_msg *m, u32 val) 912{ 913 msg_set_bits(m, 5, 0, 1, val); 914} 915 916static inline char msg_net_plane(struct tipc_msg *m) 917{ 918 return msg_bits(m, 5, 1, 7) + 'A'; 919} 920 921static inline void msg_set_net_plane(struct tipc_msg *m, char n) 922{ 923 msg_set_bits(m, 5, 1, 7, (n - 'A')); 924} 925 926static inline u32 msg_linkprio(struct tipc_msg *m) 927{ 928 return msg_bits(m, 5, 4, 0x1f); 929} 930 931static inline void msg_set_linkprio(struct tipc_msg *m, u32 n) 932{ 933 msg_set_bits(m, 5, 4, 0x1f, n); 934} 935 936static inline u32 msg_bearer_id(struct tipc_msg *m) 937{ 938 return msg_bits(m, 5, 9, 0x7); 939} 940 941static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n) 942{ 943 msg_set_bits(m, 5, 9, 0x7, n); 944} 945 946static inline u32 msg_redundant_link(struct tipc_msg *m) 947{ 948 return msg_bits(m, 5, 12, 0x1); 949} 950 951static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r) 952{ 953 msg_set_bits(m, 5, 12, 0x1, r); 954} 955 956static inline u32 msg_peer_stopping(struct tipc_msg *m) 957{ 958 return msg_bits(m, 5, 13, 0x1); 959} 960 961static inline void msg_set_peer_stopping(struct tipc_msg *m, u32 s) 962{ 963 msg_set_bits(m, 5, 13, 0x1, s); 964} 965 966static inline bool msg_bc_ack_invalid(struct tipc_msg *m) 967{ 968 switch (msg_user(m)) { 969 case BCAST_PROTOCOL: 970 case NAME_DISTRIBUTOR: 971 case LINK_PROTOCOL: 972 return msg_bits(m, 5, 14, 0x1); 973 default: 974 return false; 975 } 976} 977 978static inline void msg_set_bc_ack_invalid(struct tipc_msg *m, bool invalid) 979{ 980 msg_set_bits(m, 5, 14, 0x1, invalid); 981} 982 983static inline char *msg_media_addr(struct tipc_msg *m) 984{ 985 return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET]; 986} 987 988static inline u32 msg_bc_gap(struct tipc_msg *m) 989{ 990 return msg_bits(m, 8, 0, 0x3ff); 991} 992 993static inline void msg_set_bc_gap(struct tipc_msg *m, u32 n) 994{ 995 msg_set_bits(m, 8, 0, 0x3ff, n); 996} 997 998/* 999 * Word 9 1000 */ 1001static inline u16 msg_msgcnt(struct tipc_msg *m) 1002{ 1003 return msg_bits(m, 9, 16, 0xffff); 1004} 1005 1006static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n) 1007{ 1008 msg_set_bits(m, 9, 16, 0xffff, n); 1009} 1010 1011static inline u16 msg_syncpt(struct tipc_msg *m) 1012{ 1013 return msg_bits(m, 9, 16, 0xffff); 1014} 1015 1016static inline void msg_set_syncpt(struct tipc_msg *m, u16 n) 1017{ 1018 msg_set_bits(m, 9, 16, 0xffff, n); 1019} 1020 1021static inline u32 msg_conn_ack(struct tipc_msg *m) 1022{ 1023 return msg_bits(m, 9, 16, 0xffff); 1024} 1025 1026static inline void msg_set_conn_ack(struct tipc_msg *m, u32 n) 1027{ 1028 msg_set_bits(m, 9, 16, 0xffff, n); 1029} 1030 1031static inline u16 msg_adv_win(struct tipc_msg *m) 1032{ 1033 return msg_bits(m, 9, 0, 0xffff); 1034} 1035 1036static inline void msg_set_adv_win(struct tipc_msg *m, u16 n) 1037{ 1038 msg_set_bits(m, 9, 0, 0xffff, n); 1039} 1040 1041static inline u32 msg_max_pkt(struct tipc_msg *m) 1042{ 1043 return msg_bits(m, 9, 16, 0xffff) * 4; 1044} 1045 1046static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n) 1047{ 1048 msg_set_bits(m, 9, 16, 0xffff, (n / 4)); 1049} 1050 1051static inline u32 msg_link_tolerance(struct tipc_msg *m) 1052{ 1053 return msg_bits(m, 9, 0, 0xffff); 1054} 1055 1056static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n) 1057{ 1058 msg_set_bits(m, 9, 0, 0xffff, n); 1059} 1060 1061static inline u16 msg_grp_bc_syncpt(struct tipc_msg *m) 1062{ 1063 return msg_bits(m, 9, 16, 0xffff); 1064} 1065 1066static inline void msg_set_grp_bc_syncpt(struct tipc_msg *m, u16 n) 1067{ 1068 msg_set_bits(m, 9, 16, 0xffff, n); 1069} 1070 1071static inline u16 msg_grp_bc_acked(struct tipc_msg *m) 1072{ 1073 return msg_bits(m, 9, 16, 0xffff); 1074} 1075 1076static inline void msg_set_grp_bc_acked(struct tipc_msg *m, u16 n) 1077{ 1078 msg_set_bits(m, 9, 16, 0xffff, n); 1079} 1080 1081static inline u16 msg_grp_remitted(struct tipc_msg *m) 1082{ 1083 return msg_bits(m, 9, 16, 0xffff); 1084} 1085 1086static inline void msg_set_grp_remitted(struct tipc_msg *m, u16 n) 1087{ 1088 msg_set_bits(m, 9, 16, 0xffff, n); 1089} 1090 1091/* Word 10 1092 */ 1093static inline u16 msg_grp_evt(struct tipc_msg *m) 1094{ 1095 return msg_bits(m, 10, 0, 0x3); 1096} 1097 1098static inline void msg_set_grp_evt(struct tipc_msg *m, int n) 1099{ 1100 msg_set_bits(m, 10, 0, 0x3, n); 1101} 1102 1103static inline u16 msg_grp_bc_ack_req(struct tipc_msg *m) 1104{ 1105 return msg_bits(m, 10, 0, 0x1); 1106} 1107 1108static inline void msg_set_grp_bc_ack_req(struct tipc_msg *m, bool n) 1109{ 1110 msg_set_bits(m, 10, 0, 0x1, n); 1111} 1112 1113static inline u16 msg_grp_bc_seqno(struct tipc_msg *m) 1114{ 1115 return msg_bits(m, 10, 16, 0xffff); 1116} 1117 1118static inline void msg_set_grp_bc_seqno(struct tipc_msg *m, u32 n) 1119{ 1120 msg_set_bits(m, 10, 16, 0xffff, n); 1121} 1122 1123static inline bool msg_peer_link_is_up(struct tipc_msg *m) 1124{ 1125 if (likely(msg_user(m) != LINK_PROTOCOL)) 1126 return true; 1127 if (msg_type(m) == STATE_MSG) 1128 return true; 1129 return false; 1130} 1131 1132static inline bool msg_peer_node_is_up(struct tipc_msg *m) 1133{ 1134 if (msg_peer_link_is_up(m)) 1135 return true; 1136 return msg_redundant_link(m); 1137} 1138 1139static inline bool msg_is_reset(struct tipc_msg *hdr) 1140{ 1141 return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG); 1142} 1143 1144/* Word 13 1145 */ 1146static inline void msg_set_peer_net_hash(struct tipc_msg *m, u32 n) 1147{ 1148 msg_set_word(m, 13, n); 1149} 1150 1151static inline u32 msg_peer_net_hash(struct tipc_msg *m) 1152{ 1153 return msg_word(m, 13); 1154} 1155 1156/* Word 14 1157 */ 1158static inline u32 msg_sugg_node_addr(struct tipc_msg *m) 1159{ 1160 return msg_word(m, 14); 1161} 1162 1163static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n) 1164{ 1165 msg_set_word(m, 14, n); 1166} 1167 1168static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id) 1169{ 1170 memcpy(msg_data(hdr), id, 16); 1171} 1172 1173static inline u8 *msg_node_id(struct tipc_msg *hdr) 1174{ 1175 return (u8 *)msg_data(hdr); 1176} 1177 1178struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp); 1179bool tipc_msg_validate(struct sk_buff **_skb); 1180bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err); 1181void tipc_skb_reject(struct net *net, int err, struct sk_buff *skb, 1182 struct sk_buff_head *xmitq); 1183void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type, 1184 u32 hsize, u32 destnode); 1185struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz, 1186 uint data_sz, u32 dnode, u32 onode, 1187 u32 dport, u32 oport, int errcode); 1188int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf); 1189bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss, 1190 u32 dnode, bool *new_bundle); 1191bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos); 1192int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr, 1193 int pktmax, struct sk_buff_head *frags); 1194int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, 1195 int offset, int dsz, int mtu, struct sk_buff_head *list); 1196int tipc_msg_append(struct tipc_msg *hdr, struct msghdr *m, int dlen, 1197 int mss, struct sk_buff_head *txq); 1198bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err); 1199bool tipc_msg_assemble(struct sk_buff_head *list); 1200bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq); 1201bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg, 1202 struct sk_buff_head *cpy); 1203bool __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno, 1204 struct sk_buff *skb); 1205bool tipc_msg_skb_clone(struct sk_buff_head *msg, struct sk_buff_head *cpy); 1206 1207static inline u16 buf_seqno(struct sk_buff *skb) 1208{ 1209 return msg_seqno(buf_msg(skb)); 1210} 1211 1212static inline int buf_roundup_len(struct sk_buff *skb) 1213{ 1214 return (skb->len / 1024 + 1) * 1024; 1215} 1216 1217/* tipc_skb_peek(): peek and reserve first buffer in list 1218 * @list: list to be peeked in 1219 * Returns pointer to first buffer in list, if any 1220 */ 1221static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list, 1222 spinlock_t *lock) 1223{ 1224 struct sk_buff *skb; 1225 1226 spin_lock_bh(lock); 1227 skb = skb_peek(list); 1228 if (skb) 1229 skb_get(skb); 1230 spin_unlock_bh(lock); 1231 return skb; 1232} 1233 1234/* tipc_skb_peek_port(): find a destination port, ignoring all destinations 1235 * up to and including 'filter'. 1236 * Note: ignoring previously tried destinations minimizes the risk of 1237 * contention on the socket lock 1238 * @list: list to be peeked in 1239 * @filter: last destination to be ignored from search 1240 * Returns a destination port number, of applicable. 1241 */ 1242static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter) 1243{ 1244 struct sk_buff *skb; 1245 u32 dport = 0; 1246 bool ignore = true; 1247 1248 spin_lock_bh(&list->lock); 1249 skb_queue_walk(list, skb) { 1250 dport = msg_destport(buf_msg(skb)); 1251 if (!filter || skb_queue_is_last(list, skb)) 1252 break; 1253 if (dport == filter) 1254 ignore = false; 1255 else if (!ignore) 1256 break; 1257 } 1258 spin_unlock_bh(&list->lock); 1259 return dport; 1260} 1261 1262/* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list 1263 * @list: list to be unlinked from 1264 * @dport: selection criteria for buffer to unlink 1265 */ 1266static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list, 1267 u32 dport) 1268{ 1269 struct sk_buff *_skb, *tmp, *skb = NULL; 1270 1271 spin_lock_bh(&list->lock); 1272 skb_queue_walk_safe(list, _skb, tmp) { 1273 if (msg_destport(buf_msg(_skb)) == dport) { 1274 __skb_unlink(_skb, list); 1275 skb = _skb; 1276 break; 1277 } 1278 } 1279 spin_unlock_bh(&list->lock); 1280 return skb; 1281} 1282 1283/* tipc_skb_queue_splice_tail - append an skb list to lock protected list 1284 * @list: the new list to append. Not lock protected 1285 * @head: target list. Lock protected. 1286 */ 1287static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list, 1288 struct sk_buff_head *head) 1289{ 1290 spin_lock_bh(&head->lock); 1291 skb_queue_splice_tail(list, head); 1292 spin_unlock_bh(&head->lock); 1293} 1294 1295/* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists 1296 * @list: the new list to add. Lock protected. Will be reinitialized 1297 * @head: target list. Lock protected. 1298 */ 1299static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list, 1300 struct sk_buff_head *head) 1301{ 1302 struct sk_buff_head tmp; 1303 1304 __skb_queue_head_init(&tmp); 1305 1306 spin_lock_bh(&list->lock); 1307 skb_queue_splice_tail_init(list, &tmp); 1308 spin_unlock_bh(&list->lock); 1309 tipc_skb_queue_splice_tail(&tmp, head); 1310} 1311 1312/* __tipc_skb_dequeue() - dequeue the head skb according to expected seqno 1313 * @list: list to be dequeued from 1314 * @seqno: seqno of the expected msg 1315 * 1316 * returns skb dequeued from the list if its seqno is less than or equal to 1317 * the expected one, otherwise the skb is still hold 1318 * 1319 * Note: must be used with appropriate locks held only 1320 */ 1321static inline struct sk_buff *__tipc_skb_dequeue(struct sk_buff_head *list, 1322 u16 seqno) 1323{ 1324 struct sk_buff *skb = skb_peek(list); 1325 1326 if (skb && less_eq(buf_seqno(skb), seqno)) { 1327 __skb_unlink(skb, list); 1328 return skb; 1329 } 1330 return NULL; 1331} 1332 1333#endif 1334