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