net/tipc/msg.h

   1 /*
   2  * net/tipc/msg.h: Include file for TIPC message header routines
   3  *
   4  * Copyright (c) 2000-2007, 2014-2015 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
  69 /*
  70  * Internal message users
  71  */
  72 #define  BCAST_PROTOCOL       5
  73 #define  MSG_BUNDLER          6
  74 #define  LINK_PROTOCOL        7
  75 #define  CONN_MANAGER         8
  76 #define  TUNNEL_PROTOCOL      10
  77 #define  NAME_DISTRIBUTOR     11
  78 #define  MSG_FRAGMENTER       12
  79 #define  LINK_CONFIG          13
  80 #define  SOCK_WAKEUP          14       /* pseudo user */
  81
  82 /*
  83  * Message header sizes
  84  */
  85 #define SHORT_H_SIZE              24    /* In-cluster basic payload message */
  86 #define BASIC_H_SIZE              32    /* Basic payload message */
  87 #define NAMED_H_SIZE              40    /* Named payload message */
  88 #define MCAST_H_SIZE              44    /* Multicast payload message */
  89 #define INT_H_SIZE                40    /* Internal messages */
  90 #define MIN_H_SIZE                24    /* Smallest legal TIPC header size */
  91 #define MAX_H_SIZE                60    /* Largest possible TIPC header size */
  92
  93 #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
  94
  95 #define TIPC_MEDIA_INFO_OFFSET  5
  96
  97 /**
  98  * TIPC message buffer code
  99  *
 100  * TIPC message buffer headroom reserves space for the worst-case
 101  * link-level device header (in case the message is sent off-node).
 102  *
 103  * Note: Headroom should be a multiple of 4 to ensure the TIPC header fields
 104  *       are word aligned for quicker access
 105  */
 106 #define BUF_HEADROOM (LL_MAX_HEADER + 48)
 107
 108 struct tipc_skb_cb {
 109         void *handle;
 110         struct sk_buff *tail;
 111         bool validated;
 112         bool wakeup_pending;
 113         u16 chain_sz;
 114         u16 chain_imp;
 115         u16 ackers;
 116 };
 117
 118 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))
 119
 120 struct tipc_msg {
 121         __be32 hdr[15];
 122 };
 123
 124 static inline struct tipc_msg *buf_msg(struct sk_buff *skb)
 125 {
 126         return (struct tipc_msg *)skb->data;
 127 }
 128
 129 static inline u32 msg_word(struct tipc_msg *m, u32 pos)
 130 {
 131         return ntohl(m->hdr[pos]);
 132 }
 133
 134 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
 135 {
 136         m->hdr[w] = htonl(val);
 137 }
 138
 139 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
 140 {
 141         return (msg_word(m, w) >> pos) & mask;
 142 }
 143
 144 static inline void msg_set_bits(struct tipc_msg *m, u32 w,
 145                                 u32 pos, u32 mask, u32 val)
 146 {
 147         val = (val & mask) << pos;
 148         mask = mask << pos;
 149         m->hdr[w] &= ~htonl(mask);
 150         m->hdr[w] |= htonl(val);
 151 }
 152
 153 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)
 154 {
 155         u32 temp = msg->hdr[a];
 156
 157         msg->hdr[a] = msg->hdr[b];
 158         msg->hdr[b] = temp;
 159 }
 160
 161 /*
 162  * Word 0
 163  */
 164 static inline u32 msg_version(struct tipc_msg *m)
 165 {
 166         return msg_bits(m, 0, 29, 7);
 167 }
 168
 169 static inline void msg_set_version(struct tipc_msg *m)
 170 {
 171         msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
 172 }
 173
 174 static inline u32 msg_user(struct tipc_msg *m)
 175 {
 176         return msg_bits(m, 0, 25, 0xf);
 177 }
 178
 179 static inline u32 msg_isdata(struct tipc_msg *m)
 180 {
 181         return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
 182 }
 183
 184 static inline void msg_set_user(struct tipc_msg *m, u32 n)
 185 {
 186         msg_set_bits(m, 0, 25, 0xf, n);
 187 }
 188
 189 static inline u32 msg_hdr_sz(struct tipc_msg *m)
 190 {
 191         return msg_bits(m, 0, 21, 0xf) << 2;
 192 }
 193
 194 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
 195 {
 196         msg_set_bits(m, 0, 21, 0xf, n>>2);
 197 }
 198
 199 static inline u32 msg_size(struct tipc_msg *m)
 200 {
 201         return msg_bits(m, 0, 0, 0x1ffff);
 202 }
 203
 204 static inline u32 msg_data_sz(struct tipc_msg *m)
 205 {
 206         return msg_size(m) - msg_hdr_sz(m);
 207 }
 208
 209 static inline int msg_non_seq(struct tipc_msg *m)
 210 {
 211         return msg_bits(m, 0, 20, 1);
 212 }
 213
 214 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
 215 {
 216         msg_set_bits(m, 0, 20, 1, n);
 217 }
 218
 219 static inline int msg_dest_droppable(struct tipc_msg *m)
 220 {
 221         return msg_bits(m, 0, 19, 1);
 222 }
 223
 224 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
 225 {
 226         msg_set_bits(m, 0, 19, 1, d);
 227 }
 228
 229 static inline int msg_src_droppable(struct tipc_msg *m)
 230 {
 231         return msg_bits(m, 0, 18, 1);
 232 }
 233
 234 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
 235 {
 236         msg_set_bits(m, 0, 18, 1, d);
 237 }
 238
 239 static inline void msg_set_size(struct tipc_msg *m, u32 sz)
 240 {
 241         m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz);
 242 }
 243
 244 static inline unchar *msg_data(struct tipc_msg *m)
 245 {
 246         return ((unchar *)m) + msg_hdr_sz(m);
 247 }
 248
 249 static inline struct tipc_msg *msg_get_wrapped(struct tipc_msg *m)
 250 {
 251         return (struct tipc_msg *)msg_data(m);
 252 }
 253
 254 /*
 255  * Word 1
 256  */
 257 static inline u32 msg_type(struct tipc_msg *m)
 258 {
 259         return msg_bits(m, 1, 29, 0x7);
 260 }
 261
 262 static inline void msg_set_type(struct tipc_msg *m, u32 n)
 263 {
 264         msg_set_bits(m, 1, 29, 0x7, n);
 265 }
 266
 267 static inline u32 msg_named(struct tipc_msg *m)
 268 {
 269         return msg_type(m) == TIPC_NAMED_MSG;
 270 }
 271
 272 static inline u32 msg_mcast(struct tipc_msg *m)
 273 {
 274         return msg_type(m) == TIPC_MCAST_MSG;
 275 }
 276
 277 static inline u32 msg_connected(struct tipc_msg *m)
 278 {
 279         return msg_type(m) == TIPC_CONN_MSG;
 280 }
 281
 282 static inline u32 msg_errcode(struct tipc_msg *m)
 283 {
 284         return msg_bits(m, 1, 25, 0xf);
 285 }
 286
 287 static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
 288 {
 289         msg_set_bits(m, 1, 25, 0xf, err);
 290 }
 291
 292 static inline u32 msg_reroute_cnt(struct tipc_msg *m)
 293 {
 294         return msg_bits(m, 1, 21, 0xf);
 295 }
 296
 297 static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
 298 {
 299         msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
 300 }
 301
 302 static inline void msg_reset_reroute_cnt(struct tipc_msg *m)
 303 {
 304         msg_set_bits(m, 1, 21, 0xf, 0);
 305 }
 306
 307 static inline u32 msg_lookup_scope(struct tipc_msg *m)
 308 {
 309         return msg_bits(m, 1, 19, 0x3);
 310 }
 311
 312 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
 313 {
 314         msg_set_bits(m, 1, 19, 0x3, n);
 315 }
 316
 317 static inline u16 msg_bcast_ack(struct tipc_msg *m)
 318 {
 319         return msg_bits(m, 1, 0, 0xffff);
 320 }
 321
 322 static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n)
 323 {
 324         msg_set_bits(m, 1, 0, 0xffff, n);
 325 }
 326
 327
 328 /*
 329  * Word 2
 330  */
 331 static inline u16 msg_ack(struct tipc_msg *m)
 332 {
 333         return msg_bits(m, 2, 16, 0xffff);
 334 }
 335
 336 static inline void msg_set_ack(struct tipc_msg *m, u16 n)
 337 {
 338         msg_set_bits(m, 2, 16, 0xffff, n);
 339 }
 340
 341 static inline u16 msg_seqno(struct tipc_msg *m)
 342 {
 343         return msg_bits(m, 2, 0, 0xffff);
 344 }
 345
 346 static inline void msg_set_seqno(struct tipc_msg *m, u16 n)
 347 {
 348         msg_set_bits(m, 2, 0, 0xffff, n);
 349 }
 350
 351 /*
 352  * Words 3-10
 353  */
 354 static inline u32 msg_importance(struct tipc_msg *m)
 355 {
 356         int usr = msg_user(m);
 357
 358         if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m)))
 359                 return usr;
 360         if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))
 361                 return msg_bits(m, 9, 0, 0x7);
 362         return TIPC_SYSTEM_IMPORTANCE;
 363 }
 364
 365 static inline void msg_set_importance(struct tipc_msg *m, u32 i)
 366 {
 367         int usr = msg_user(m);
 368
 369         if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)))
 370                 msg_set_bits(m, 9, 0, 0x7, i);
 371         else if (i < TIPC_SYSTEM_IMPORTANCE)
 372                 msg_set_user(m, i);
 373         else
 374                 pr_warn("Trying to set illegal importance in message\n");
 375 }
 376
 377 static inline u32 msg_prevnode(struct tipc_msg *m)
 378 {
 379         return msg_word(m, 3);
 380 }
 381
 382 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
 383 {
 384         msg_set_word(m, 3, a);
 385 }
 386
 387 static inline u32 msg_origport(struct tipc_msg *m)
 388 {
 389         if (msg_user(m) == MSG_FRAGMENTER)
 390                 m = msg_get_wrapped(m);
 391         return msg_word(m, 4);
 392 }
 393
 394 static inline void msg_set_origport(struct tipc_msg *m, u32 p)
 395 {
 396         msg_set_word(m, 4, p);
 397 }
 398
 399 static inline u32 msg_destport(struct tipc_msg *m)
 400 {
 401         return msg_word(m, 5);
 402 }
 403
 404 static inline void msg_set_destport(struct tipc_msg *m, u32 p)
 405 {
 406         msg_set_word(m, 5, p);
 407 }
 408
 409 static inline u32 msg_mc_netid(struct tipc_msg *m)
 410 {
 411         return msg_word(m, 5);
 412 }
 413
 414 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
 415 {
 416         msg_set_word(m, 5, p);
 417 }
 418
 419 static inline int msg_short(struct tipc_msg *m)
 420 {
 421         return msg_hdr_sz(m) == SHORT_H_SIZE;
 422 }
 423
 424 static inline u32 msg_orignode(struct tipc_msg *m)
 425 {
 426         if (likely(msg_short(m)))
 427                 return msg_prevnode(m);
 428         return msg_word(m, 6);
 429 }
 430
 431 static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
 432 {
 433         msg_set_word(m, 6, a);
 434 }
 435
 436 static inline u32 msg_destnode(struct tipc_msg *m)
 437 {
 438         return msg_word(m, 7);
 439 }
 440
 441 static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
 442 {
 443         msg_set_word(m, 7, a);
 444 }
 445
 446 static inline u32 msg_nametype(struct tipc_msg *m)
 447 {
 448         return msg_word(m, 8);
 449 }
 450
 451 static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
 452 {
 453         msg_set_word(m, 8, n);
 454 }
 455
 456 static inline u32 msg_nameinst(struct tipc_msg *m)
 457 {
 458         return msg_word(m, 9);
 459 }
 460
 461 static inline u32 msg_namelower(struct tipc_msg *m)
 462 {
 463         return msg_nameinst(m);
 464 }
 465
 466 static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
 467 {
 468         msg_set_word(m, 9, n);
 469 }
 470
 471 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
 472 {
 473         msg_set_namelower(m, n);
 474 }
 475
 476 static inline u32 msg_nameupper(struct tipc_msg *m)
 477 {
 478         return msg_word(m, 10);
 479 }
 480
 481 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
 482 {
 483         msg_set_word(m, 10, n);
 484 }
 485
 486 /*
 487  * Constants and routines used to read and write TIPC internal message headers
 488  */
 489
 490 /*
 491  *  Connection management protocol message types
 492  */
 493 #define CONN_PROBE        0
 494 #define CONN_PROBE_REPLY  1
 495 #define CONN_ACK          2
 496
 497 /*
 498  * Name distributor message types
 499  */
 500 #define PUBLICATION       0
 501 #define WITHDRAWAL        1
 502
 503 /*
 504  * Segmentation message types
 505  */
 506 #define FIRST_FRAGMENT          0
 507 #define FRAGMENT                1
 508 #define LAST_FRAGMENT           2
 509
 510 /*
 511  * Link management protocol message types
 512  */
 513 #define STATE_MSG               0
 514 #define RESET_MSG               1
 515 #define ACTIVATE_MSG            2
 516
 517 /*
 518  * Changeover tunnel message types
 519  */
 520 #define SYNCH_MSG               0
 521 #define FAILOVER_MSG            1
 522
 523 /*
 524  * Config protocol message types
 525  */
 526 #define DSC_REQ_MSG             0
 527 #define DSC_RESP_MSG            1
 528
 529 /*
 530  * Word 1
 531  */
 532 static inline u32 msg_seq_gap(struct tipc_msg *m)
 533 {
 534         return msg_bits(m, 1, 16, 0x1fff);
 535 }
 536
 537 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
 538 {
 539         msg_set_bits(m, 1, 16, 0x1fff, n);
 540 }
 541
 542 static inline u32 msg_node_sig(struct tipc_msg *m)
 543 {
 544         return msg_bits(m, 1, 0, 0xffff);
 545 }
 546
 547 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
 548 {
 549         msg_set_bits(m, 1, 0, 0xffff, n);
 550 }
 551
 552 static inline u32 msg_node_capabilities(struct tipc_msg *m)
 553 {
 554         return msg_bits(m, 1, 15, 0x1fff);
 555 }
 556
 557 static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n)
 558 {
 559         msg_set_bits(m, 1, 15, 0x1fff, n);
 560 }
 561
 562 /*
 563  * Word 2
 564  */
 565 static inline u32 msg_dest_domain(struct tipc_msg *m)
 566 {
 567         return msg_word(m, 2);
 568 }
 569
 570 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
 571 {
 572         msg_set_word(m, 2, n);
 573 }
 574
 575 static inline u32 msg_bcgap_after(struct tipc_msg *m)
 576 {
 577         return msg_bits(m, 2, 16, 0xffff);
 578 }
 579
 580 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
 581 {
 582         msg_set_bits(m, 2, 16, 0xffff, n);
 583 }
 584
 585 static inline u32 msg_bcgap_to(struct tipc_msg *m)
 586 {
 587         return msg_bits(m, 2, 0, 0xffff);
 588 }
 589
 590 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
 591 {
 592         msg_set_bits(m, 2, 0, 0xffff, n);
 593 }
 594
 595
 596 /*
 597  * Word 4
 598  */
 599 static inline u32 msg_last_bcast(struct tipc_msg *m)
 600 {
 601         return msg_bits(m, 4, 16, 0xffff);
 602 }
 603
 604 static inline u32 msg_bc_snd_nxt(struct tipc_msg *m)
 605 {
 606         return msg_last_bcast(m) + 1;
 607 }
 608
 609 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
 610 {
 611         msg_set_bits(m, 4, 16, 0xffff, n);
 612 }
 613
 614 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
 615 {
 616         msg_set_bits(m, 4, 16, 0xffff, n);
 617 }
 618
 619
 620 static inline u16 msg_next_sent(struct tipc_msg *m)
 621 {
 622         return msg_bits(m, 4, 0, 0xffff);
 623 }
 624
 625 static inline void msg_set_next_sent(struct tipc_msg *m, u16 n)
 626 {
 627         msg_set_bits(m, 4, 0, 0xffff, n);
 628 }
 629
 630 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
 631 {
 632         msg_set_bits(m, 4, 0, 0xffff, n);
 633 }
 634
 635 static inline u32 msg_bc_netid(struct tipc_msg *m)
 636 {
 637         return msg_word(m, 4);
 638 }
 639
 640 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
 641 {
 642         msg_set_word(m, 4, id);
 643 }
 644
 645 static inline u32 msg_link_selector(struct tipc_msg *m)
 646 {
 647         return msg_bits(m, 4, 0, 1);
 648 }
 649
 650 static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
 651 {
 652         msg_set_bits(m, 4, 0, 1, n);
 653 }
 654
 655 /*
 656  * Word 5
 657  */
 658 static inline u16 msg_session(struct tipc_msg *m)
 659 {
 660         return msg_bits(m, 5, 16, 0xffff);
 661 }
 662
 663 static inline void msg_set_session(struct tipc_msg *m, u16 n)
 664 {
 665         msg_set_bits(m, 5, 16, 0xffff, n);
 666 }
 667
 668 static inline u32 msg_probe(struct tipc_msg *m)
 669 {
 670         return msg_bits(m, 5, 0, 1);
 671 }
 672
 673 static inline void msg_set_probe(struct tipc_msg *m, u32 val)
 674 {
 675         msg_set_bits(m, 5, 0, 1, val);
 676 }
 677
 678 static inline char msg_net_plane(struct tipc_msg *m)
 679 {
 680         return msg_bits(m, 5, 1, 7) + 'A';
 681 }
 682
 683 static inline void msg_set_net_plane(struct tipc_msg *m, char n)
 684 {
 685         msg_set_bits(m, 5, 1, 7, (n - 'A'));
 686 }
 687
 688 static inline u32 msg_linkprio(struct tipc_msg *m)
 689 {
 690         return msg_bits(m, 5, 4, 0x1f);
 691 }
 692
 693 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
 694 {
 695         msg_set_bits(m, 5, 4, 0x1f, n);
 696 }
 697
 698 static inline u32 msg_bearer_id(struct tipc_msg *m)
 699 {
 700         return msg_bits(m, 5, 9, 0x7);
 701 }
 702
 703 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
 704 {
 705         msg_set_bits(m, 5, 9, 0x7, n);
 706 }
 707
 708 static inline u32 msg_redundant_link(struct tipc_msg *m)
 709 {
 710         return msg_bits(m, 5, 12, 0x1);
 711 }
 712
 713 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
 714 {
 715         msg_set_bits(m, 5, 12, 0x1, r);
 716 }
 717
 718 static inline char *msg_media_addr(struct tipc_msg *m)
 719 {
 720         return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET];
 721 }
 722
 723 /*
 724  * Word 9
 725  */
 726 static inline u16 msg_msgcnt(struct tipc_msg *m)
 727 {
 728         return msg_bits(m, 9, 16, 0xffff);
 729 }
 730
 731 static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n)
 732 {
 733         msg_set_bits(m, 9, 16, 0xffff, n);
 734 }
 735
 736 static inline u32 msg_bcast_tag(struct tipc_msg *m)
 737 {
 738         return msg_bits(m, 9, 16, 0xffff);
 739 }
 740
 741 static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
 742 {
 743         msg_set_bits(m, 9, 16, 0xffff, n);
 744 }
 745
 746 static inline u32 msg_max_pkt(struct tipc_msg *m)
 747 {
 748         return msg_bits(m, 9, 16, 0xffff) * 4;
 749 }
 750
 751 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
 752 {
 753         msg_set_bits(m, 9, 16, 0xffff, (n / 4));
 754 }
 755
 756 static inline u32 msg_link_tolerance(struct tipc_msg *m)
 757 {
 758         return msg_bits(m, 9, 0, 0xffff);
 759 }
 760
 761 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
 762 {
 763         msg_set_bits(m, 9, 0, 0xffff, n);
 764 }
 765
 766 static inline bool msg_peer_link_is_up(struct tipc_msg *m)
 767 {
 768         if (likely(msg_user(m) != LINK_PROTOCOL))
 769                 return true;
 770         if (msg_type(m) == STATE_MSG)
 771                 return true;
 772         return false;
 773 }
 774
 775 static inline bool msg_peer_node_is_up(struct tipc_msg *m)
 776 {
 777         if (msg_peer_link_is_up(m))
 778                 return true;
 779         return msg_redundant_link(m);
 780 }
 781
 782 static inline bool msg_is_reset(struct tipc_msg *hdr)
 783 {
 784         return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG);
 785 }
 786
 787 struct sk_buff *tipc_buf_acquire(u32 size);
 788 bool tipc_msg_validate(struct sk_buff *skb);
 789 bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err);
 790 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type,
 791                    u32 hsize, u32 destnode);
 792 struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
 793                                 uint data_sz, u32 dnode, u32 onode,
 794                                 u32 dport, u32 oport, int errcode);
 795 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);
 796 bool tipc_msg_bundle(struct sk_buff *skb, struct tipc_msg *msg, u32 mtu);
 797 bool tipc_msg_make_bundle(struct sk_buff **skb, struct tipc_msg *msg,
 798                           u32 mtu, u32 dnode);
 799 bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos);
 800 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
 801                    int offset, int dsz, int mtu, struct sk_buff_head *list);
 802 bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err);
 803 bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq);
 804 void __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno,
 805                              struct sk_buff *skb);
 806
 807 static inline u16 buf_seqno(struct sk_buff *skb)
 808 {
 809         return msg_seqno(buf_msg(skb));
 810 }
 811
 812 /* tipc_skb_peek(): peek and reserve first buffer in list
 813  * @list: list to be peeked in
 814  * Returns pointer to first buffer in list, if any
 815  */
 816 static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list,
 817                                             spinlock_t *lock)
 818 {
 819         struct sk_buff *skb;
 820
 821         spin_lock_bh(lock);
 822         skb = skb_peek(list);
 823         if (skb)
 824                 skb_get(skb);
 825         spin_unlock_bh(lock);
 826         return skb;
 827 }
 828
 829 /* tipc_skb_peek_port(): find a destination port, ignoring all destinations
 830  *                       up to and including 'filter'.
 831  * Note: ignoring previously tried destinations minimizes the risk of
 832  *       contention on the socket lock
 833  * @list: list to be peeked in
 834  * @filter: last destination to be ignored from search
 835  * Returns a destination port number, of applicable.
 836  */
 837 static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter)
 838 {
 839         struct sk_buff *skb;
 840         u32 dport = 0;
 841         bool ignore = true;
 842
 843         spin_lock_bh(&list->lock);
 844         skb_queue_walk(list, skb) {
 845                 dport = msg_destport(buf_msg(skb));
 846                 if (!filter || skb_queue_is_last(list, skb))
 847                         break;
 848                 if (dport == filter)
 849                         ignore = false;
 850                 else if (!ignore)
 851                         break;
 852         }
 853         spin_unlock_bh(&list->lock);
 854         return dport;
 855 }
 856
 857 /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list
 858  * @list: list to be unlinked from
 859  * @dport: selection criteria for buffer to unlink
 860  */
 861 static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list,
 862                                                u32 dport)
 863 {
 864         struct sk_buff *_skb, *tmp, *skb = NULL;
 865
 866         spin_lock_bh(&list->lock);
 867         skb_queue_walk_safe(list, _skb, tmp) {
 868                 if (msg_destport(buf_msg(_skb)) == dport) {
 869                         __skb_unlink(_skb, list);
 870                         skb = _skb;
 871                         break;
 872                 }
 873         }
 874         spin_unlock_bh(&list->lock);
 875         return skb;
 876 }
 877
 878 /* tipc_skb_queue_splice_tail - append an skb list to lock protected list
 879  * @list: the new list to append. Not lock protected
 880  * @head: target list. Lock protected.
 881  */
 882 static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list,
 883                                               struct sk_buff_head *head)
 884 {
 885         spin_lock_bh(&head->lock);
 886         skb_queue_splice_tail(list, head);
 887         spin_unlock_bh(&head->lock);
 888 }
 889
 890 /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists
 891  * @list: the new list to add. Lock protected. Will be reinitialized
 892  * @head: target list. Lock protected.
 893  */
 894 static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list,
 895                                                    struct sk_buff_head *head)
 896 {
 897         struct sk_buff_head tmp;
 898
 899         __skb_queue_head_init(&tmp);
 900
 901         spin_lock_bh(&list->lock);
 902         skb_queue_splice_tail_init(list, &tmp);
 903         spin_unlock_bh(&list->lock);
 904         tipc_skb_queue_splice_tail(&tmp, head);
 905 }
 906
 907 #endif