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