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