net/tipc/msg.h

   1 /*
   2  * net/tipc/msg.h: Include file for TIPC message header routines
   3  *
   4  * Copyright (c) 2000-2007, 2014, 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
  42 /*
  43  * Constants and routines used to read and write TIPC payload message headers
  44  *
  45  * Note: Some items are also used with TIPC internal message headers
  46  */
  47 #define TIPC_VERSION              2
  48
  49 /*
  50  * Payload message users are defined in TIPC's public API:
  51  * - TIPC_LOW_IMPORTANCE
  52  * - TIPC_MEDIUM_IMPORTANCE
  53  * - TIPC_HIGH_IMPORTANCE
  54  * - TIPC_CRITICAL_IMPORTANCE
  55  */
  56
  57 /*
  58  * Payload message types
  59  */
  60 #define TIPC_CONN_MSG           0
  61 #define TIPC_MCAST_MSG          1
  62 #define TIPC_NAMED_MSG          2
  63 #define TIPC_DIRECT_MSG         3
  64
  65 /*
  66  * Message header sizes
  67  */
  68 #define SHORT_H_SIZE              24    /* In-cluster basic payload message */
  69 #define BASIC_H_SIZE              32    /* Basic payload message */
  70 #define NAMED_H_SIZE              40    /* Named payload message */
  71 #define MCAST_H_SIZE              44    /* Multicast payload message */
  72 #define INT_H_SIZE                40    /* Internal messages */
  73 #define MIN_H_SIZE                24    /* Smallest legal TIPC header size */
  74 #define MAX_H_SIZE                60    /* Largest possible TIPC header size */
  75
  76 #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
  77
  78 #define TIPC_MEDIA_ADDR_OFFSET  5
  79
  80 /**
  81  * TIPC message buffer code
  82  *
  83  * TIPC message buffer headroom reserves space for the worst-case
  84  * link-level device header (in case the message is sent off-node).
  85  *
  86  * Note: Headroom should be a multiple of 4 to ensure the TIPC header fields
  87  *       are word aligned for quicker access
  88  */
  89 #define BUF_HEADROOM LL_MAX_HEADER
  90
  91 struct tipc_skb_cb {
  92         void *handle;
  93         struct sk_buff *tail;
  94         bool deferred;
  95         bool wakeup_pending;
  96         bool bundling;
  97         u16 chain_sz;
  98         u16 chain_imp;
  99 };
 100
 101 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))
 102
 103 struct tipc_msg {
 104         __be32 hdr[15];
 105 };
 106
 107 static inline struct tipc_msg *buf_msg(struct sk_buff *skb)
 108 {
 109         return (struct tipc_msg *)skb->data;
 110 }
 111
 112 static inline u32 msg_word(struct tipc_msg *m, u32 pos)
 113 {
 114         return ntohl(m->hdr[pos]);
 115 }
 116
 117 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
 118 {
 119         m->hdr[w] = htonl(val);
 120 }
 121
 122 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
 123 {
 124         return (msg_word(m, w) >> pos) & mask;
 125 }
 126
 127 static inline void msg_set_bits(struct tipc_msg *m, u32 w,
 128                                 u32 pos, u32 mask, u32 val)
 129 {
 130         val = (val & mask) << pos;
 131         mask = mask << pos;
 132         m->hdr[w] &= ~htonl(mask);
 133         m->hdr[w] |= htonl(val);
 134 }
 135
 136 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)
 137 {
 138         u32 temp = msg->hdr[a];
 139
 140         msg->hdr[a] = msg->hdr[b];
 141         msg->hdr[b] = temp;
 142 }
 143
 144 /*
 145  * Word 0
 146  */
 147 static inline u32 msg_version(struct tipc_msg *m)
 148 {
 149         return msg_bits(m, 0, 29, 7);
 150 }
 151
 152 static inline void msg_set_version(struct tipc_msg *m)
 153 {
 154         msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
 155 }
 156
 157 static inline u32 msg_user(struct tipc_msg *m)
 158 {
 159         return msg_bits(m, 0, 25, 0xf);
 160 }
 161
 162 static inline u32 msg_isdata(struct tipc_msg *m)
 163 {
 164         return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
 165 }
 166
 167 static inline void msg_set_user(struct tipc_msg *m, u32 n)
 168 {
 169         msg_set_bits(m, 0, 25, 0xf, n);
 170 }
 171
 172 static inline u32 msg_importance(struct tipc_msg *m)
 173 {
 174         return msg_bits(m, 0, 25, 0xf);
 175 }
 176
 177 static inline void msg_set_importance(struct tipc_msg *m, u32 i)
 178 {
 179         msg_set_user(m, i);
 180 }
 181
 182 static inline u32 msg_hdr_sz(struct tipc_msg *m)
 183 {
 184         return msg_bits(m, 0, 21, 0xf) << 2;
 185 }
 186
 187 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
 188 {
 189         msg_set_bits(m, 0, 21, 0xf, n>>2);
 190 }
 191
 192 static inline u32 msg_size(struct tipc_msg *m)
 193 {
 194         return msg_bits(m, 0, 0, 0x1ffff);
 195 }
 196
 197 static inline u32 msg_data_sz(struct tipc_msg *m)
 198 {
 199         return msg_size(m) - msg_hdr_sz(m);
 200 }
 201
 202 static inline int msg_non_seq(struct tipc_msg *m)
 203 {
 204         return msg_bits(m, 0, 20, 1);
 205 }
 206
 207 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
 208 {
 209         msg_set_bits(m, 0, 20, 1, n);
 210 }
 211
 212 static inline int msg_dest_droppable(struct tipc_msg *m)
 213 {
 214         return msg_bits(m, 0, 19, 1);
 215 }
 216
 217 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
 218 {
 219         msg_set_bits(m, 0, 19, 1, d);
 220 }
 221
 222 static inline int msg_src_droppable(struct tipc_msg *m)
 223 {
 224         return msg_bits(m, 0, 18, 1);
 225 }
 226
 227 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
 228 {
 229         msg_set_bits(m, 0, 18, 1, d);
 230 }
 231
 232 static inline void msg_set_size(struct tipc_msg *m, u32 sz)
 233 {
 234         m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz);
 235 }
 236
 237
 238 /*
 239  * Word 1
 240  */
 241 static inline u32 msg_type(struct tipc_msg *m)
 242 {
 243         return msg_bits(m, 1, 29, 0x7);
 244 }
 245
 246 static inline void msg_set_type(struct tipc_msg *m, u32 n)
 247 {
 248         msg_set_bits(m, 1, 29, 0x7, n);
 249 }
 250
 251 static inline u32 msg_named(struct tipc_msg *m)
 252 {
 253         return msg_type(m) == TIPC_NAMED_MSG;
 254 }
 255
 256 static inline u32 msg_mcast(struct tipc_msg *m)
 257 {
 258         return msg_type(m) == TIPC_MCAST_MSG;
 259 }
 260
 261 static inline u32 msg_connected(struct tipc_msg *m)
 262 {
 263         return msg_type(m) == TIPC_CONN_MSG;
 264 }
 265
 266 static inline u32 msg_errcode(struct tipc_msg *m)
 267 {
 268         return msg_bits(m, 1, 25, 0xf);
 269 }
 270
 271 static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
 272 {
 273         msg_set_bits(m, 1, 25, 0xf, err);
 274 }
 275
 276 static inline u32 msg_reroute_cnt(struct tipc_msg *m)
 277 {
 278         return msg_bits(m, 1, 21, 0xf);
 279 }
 280
 281 static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
 282 {
 283         msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
 284 }
 285
 286 static inline void msg_reset_reroute_cnt(struct tipc_msg *m)
 287 {
 288         msg_set_bits(m, 1, 21, 0xf, 0);
 289 }
 290
 291 static inline u32 msg_lookup_scope(struct tipc_msg *m)
 292 {
 293         return msg_bits(m, 1, 19, 0x3);
 294 }
 295
 296 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
 297 {
 298         msg_set_bits(m, 1, 19, 0x3, n);
 299 }
 300
 301 static inline u32 msg_bcast_ack(struct tipc_msg *m)
 302 {
 303         return msg_bits(m, 1, 0, 0xffff);
 304 }
 305
 306 static inline void msg_set_bcast_ack(struct tipc_msg *m, u32 n)
 307 {
 308         msg_set_bits(m, 1, 0, 0xffff, n);
 309 }
 310
 311
 312 /*
 313  * Word 2
 314  */
 315 static inline u32 msg_ack(struct tipc_msg *m)
 316 {
 317         return msg_bits(m, 2, 16, 0xffff);
 318 }
 319
 320 static inline void msg_set_ack(struct tipc_msg *m, u32 n)
 321 {
 322         msg_set_bits(m, 2, 16, 0xffff, n);
 323 }
 324
 325 static inline u32 msg_seqno(struct tipc_msg *m)
 326 {
 327         return msg_bits(m, 2, 0, 0xffff);
 328 }
 329
 330 static inline void msg_set_seqno(struct tipc_msg *m, u32 n)
 331 {
 332         msg_set_bits(m, 2, 0, 0xffff, n);
 333 }
 334
 335 /*
 336  * Words 3-10
 337  */
 338 static inline u32 msg_prevnode(struct tipc_msg *m)
 339 {
 340         return msg_word(m, 3);
 341 }
 342
 343 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
 344 {
 345         msg_set_word(m, 3, a);
 346 }
 347
 348 static inline u32 msg_origport(struct tipc_msg *m)
 349 {
 350         return msg_word(m, 4);
 351 }
 352
 353 static inline void msg_set_origport(struct tipc_msg *m, u32 p)
 354 {
 355         msg_set_word(m, 4, p);
 356 }
 357
 358 static inline u32 msg_destport(struct tipc_msg *m)
 359 {
 360         return msg_word(m, 5);
 361 }
 362
 363 static inline void msg_set_destport(struct tipc_msg *m, u32 p)
 364 {
 365         msg_set_word(m, 5, p);
 366 }
 367
 368 static inline u32 msg_mc_netid(struct tipc_msg *m)
 369 {
 370         return msg_word(m, 5);
 371 }
 372
 373 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
 374 {
 375         msg_set_word(m, 5, p);
 376 }
 377
 378 static inline int msg_short(struct tipc_msg *m)
 379 {
 380         return msg_hdr_sz(m) == SHORT_H_SIZE;
 381 }
 382
 383 static inline u32 msg_orignode(struct tipc_msg *m)
 384 {
 385         if (likely(msg_short(m)))
 386                 return msg_prevnode(m);
 387         return msg_word(m, 6);
 388 }
 389
 390 static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
 391 {
 392         msg_set_word(m, 6, a);
 393 }
 394
 395 static inline u32 msg_destnode(struct tipc_msg *m)
 396 {
 397         return msg_word(m, 7);
 398 }
 399
 400 static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
 401 {
 402         msg_set_word(m, 7, a);
 403 }
 404
 405 static inline u32 msg_nametype(struct tipc_msg *m)
 406 {
 407         return msg_word(m, 8);
 408 }
 409
 410 static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
 411 {
 412         msg_set_word(m, 8, n);
 413 }
 414
 415 static inline u32 msg_nameinst(struct tipc_msg *m)
 416 {
 417         return msg_word(m, 9);
 418 }
 419
 420 static inline u32 msg_namelower(struct tipc_msg *m)
 421 {
 422         return msg_nameinst(m);
 423 }
 424
 425 static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
 426 {
 427         msg_set_word(m, 9, n);
 428 }
 429
 430 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
 431 {
 432         msg_set_namelower(m, n);
 433 }
 434
 435 static inline u32 msg_nameupper(struct tipc_msg *m)
 436 {
 437         return msg_word(m, 10);
 438 }
 439
 440 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
 441 {
 442         msg_set_word(m, 10, n);
 443 }
 444
 445 static inline unchar *msg_data(struct tipc_msg *m)
 446 {
 447         return ((unchar *)m) + msg_hdr_sz(m);
 448 }
 449
 450 static inline struct tipc_msg *msg_get_wrapped(struct tipc_msg *m)
 451 {
 452         return (struct tipc_msg *)msg_data(m);
 453 }
 454
 455 /*
 456  * Constants and routines used to read and write TIPC internal message headers
 457  */
 458
 459 /*
 460  * Internal message users
 461  */
 462 #define  BCAST_PROTOCOL       5
 463 #define  MSG_BUNDLER          6
 464 #define  LINK_PROTOCOL        7
 465 #define  CONN_MANAGER         8
 466 #define  ROUTE_DISTRIBUTOR    9         /* obsoleted */
 467 #define  CHANGEOVER_PROTOCOL  10
 468 #define  NAME_DISTRIBUTOR     11
 469 #define  MSG_FRAGMENTER       12
 470 #define  LINK_CONFIG          13
 471 #define  SOCK_WAKEUP          14       /* pseudo user */
 472
 473 /*
 474  *  Connection management protocol message types
 475  */
 476 #define CONN_PROBE        0
 477 #define CONN_PROBE_REPLY  1
 478 #define CONN_ACK          2
 479
 480 /*
 481  * Name distributor message types
 482  */
 483 #define PUBLICATION       0
 484 #define WITHDRAWAL        1
 485
 486 /*
 487  * Segmentation message types
 488  */
 489 #define FIRST_FRAGMENT          0
 490 #define FRAGMENT                1
 491 #define LAST_FRAGMENT           2
 492
 493 /*
 494  * Link management protocol message types
 495  */
 496 #define STATE_MSG               0
 497 #define RESET_MSG               1
 498 #define ACTIVATE_MSG            2
 499
 500 /*
 501  * Changeover tunnel message types
 502  */
 503 #define DUPLICATE_MSG           0
 504 #define ORIGINAL_MSG            1
 505
 506 /*
 507  * Config protocol message types
 508  */
 509 #define DSC_REQ_MSG             0
 510 #define DSC_RESP_MSG            1
 511
 512
 513 /*
 514  * Word 1
 515  */
 516 static inline u32 msg_seq_gap(struct tipc_msg *m)
 517 {
 518         return msg_bits(m, 1, 16, 0x1fff);
 519 }
 520
 521 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
 522 {
 523         msg_set_bits(m, 1, 16, 0x1fff, n);
 524 }
 525
 526 static inline u32 msg_node_sig(struct tipc_msg *m)
 527 {
 528         return msg_bits(m, 1, 0, 0xffff);
 529 }
 530
 531 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
 532 {
 533         msg_set_bits(m, 1, 0, 0xffff, n);
 534 }
 535
 536
 537 /*
 538  * Word 2
 539  */
 540 static inline u32 msg_dest_domain(struct tipc_msg *m)
 541 {
 542         return msg_word(m, 2);
 543 }
 544
 545 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
 546 {
 547         msg_set_word(m, 2, n);
 548 }
 549
 550 static inline u32 msg_bcgap_after(struct tipc_msg *m)
 551 {
 552         return msg_bits(m, 2, 16, 0xffff);
 553 }
 554
 555 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
 556 {
 557         msg_set_bits(m, 2, 16, 0xffff, n);
 558 }
 559
 560 static inline u32 msg_bcgap_to(struct tipc_msg *m)
 561 {
 562         return msg_bits(m, 2, 0, 0xffff);
 563 }
 564
 565 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
 566 {
 567         msg_set_bits(m, 2, 0, 0xffff, n);
 568 }
 569
 570
 571 /*
 572  * Word 4
 573  */
 574 static inline u32 msg_last_bcast(struct tipc_msg *m)
 575 {
 576         return msg_bits(m, 4, 16, 0xffff);
 577 }
 578
 579 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
 580 {
 581         msg_set_bits(m, 4, 16, 0xffff, n);
 582 }
 583
 584 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
 585 {
 586         msg_set_bits(m, 4, 16, 0xffff, n);
 587 }
 588
 589
 590 static inline u32 msg_next_sent(struct tipc_msg *m)
 591 {
 592         return msg_bits(m, 4, 0, 0xffff);
 593 }
 594
 595 static inline void msg_set_next_sent(struct tipc_msg *m, u32 n)
 596 {
 597         msg_set_bits(m, 4, 0, 0xffff, n);
 598 }
 599
 600 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)
 601 {
 602         msg_set_bits(m, 4, 0, 0xffff, n);
 603 }
 604
 605 static inline u32 msg_bc_netid(struct tipc_msg *m)
 606 {
 607         return msg_word(m, 4);
 608 }
 609
 610 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
 611 {
 612         msg_set_word(m, 4, id);
 613 }
 614
 615 static inline u32 msg_link_selector(struct tipc_msg *m)
 616 {
 617         return msg_bits(m, 4, 0, 1);
 618 }
 619
 620 static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)
 621 {
 622         msg_set_bits(m, 4, 0, 1, n);
 623 }
 624
 625 /*
 626  * Word 5
 627  */
 628 static inline u32 msg_session(struct tipc_msg *m)
 629 {
 630         return msg_bits(m, 5, 16, 0xffff);
 631 }
 632
 633 static inline void msg_set_session(struct tipc_msg *m, u32 n)
 634 {
 635         msg_set_bits(m, 5, 16, 0xffff, n);
 636 }
 637
 638 static inline u32 msg_probe(struct tipc_msg *m)
 639 {
 640         return msg_bits(m, 5, 0, 1);
 641 }
 642
 643 static inline void msg_set_probe(struct tipc_msg *m, u32 val)
 644 {
 645         msg_set_bits(m, 5, 0, 1, val);
 646 }
 647
 648 static inline char msg_net_plane(struct tipc_msg *m)
 649 {
 650         return msg_bits(m, 5, 1, 7) + 'A';
 651 }
 652
 653 static inline void msg_set_net_plane(struct tipc_msg *m, char n)
 654 {
 655         msg_set_bits(m, 5, 1, 7, (n - 'A'));
 656 }
 657
 658 static inline u32 msg_linkprio(struct tipc_msg *m)
 659 {
 660         return msg_bits(m, 5, 4, 0x1f);
 661 }
 662
 663 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
 664 {
 665         msg_set_bits(m, 5, 4, 0x1f, n);
 666 }
 667
 668 static inline u32 msg_bearer_id(struct tipc_msg *m)
 669 {
 670         return msg_bits(m, 5, 9, 0x7);
 671 }
 672
 673 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
 674 {
 675         msg_set_bits(m, 5, 9, 0x7, n);
 676 }
 677
 678 static inline u32 msg_redundant_link(struct tipc_msg *m)
 679 {
 680         return msg_bits(m, 5, 12, 0x1);
 681 }
 682
 683 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
 684 {
 685         msg_set_bits(m, 5, 12, 0x1, r);
 686 }
 687
 688 static inline char *msg_media_addr(struct tipc_msg *m)
 689 {
 690         return (char *)&m->hdr[TIPC_MEDIA_ADDR_OFFSET];
 691 }
 692
 693 /*
 694  * Word 9
 695  */
 696 static inline u32 msg_msgcnt(struct tipc_msg *m)
 697 {
 698         return msg_bits(m, 9, 16, 0xffff);
 699 }
 700
 701 static inline void msg_set_msgcnt(struct tipc_msg *m, u32 n)
 702 {
 703         msg_set_bits(m, 9, 16, 0xffff, n);
 704 }
 705
 706 static inline u32 msg_bcast_tag(struct tipc_msg *m)
 707 {
 708         return msg_bits(m, 9, 16, 0xffff);
 709 }
 710
 711 static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)
 712 {
 713         msg_set_bits(m, 9, 16, 0xffff, n);
 714 }
 715
 716 static inline u32 msg_max_pkt(struct tipc_msg *m)
 717 {
 718         return msg_bits(m, 9, 16, 0xffff) * 4;
 719 }
 720
 721 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
 722 {
 723         msg_set_bits(m, 9, 16, 0xffff, (n / 4));
 724 }
 725
 726 static inline u32 msg_link_tolerance(struct tipc_msg *m)
 727 {
 728         return msg_bits(m, 9, 0, 0xffff);
 729 }
 730
 731 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
 732 {
 733         msg_set_bits(m, 9, 0, 0xffff, n);
 734 }
 735
 736 static inline u32 tipc_msg_tot_importance(struct tipc_msg *m)
 737 {
 738         if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
 739                 return msg_importance(msg_get_wrapped(m));
 740         return msg_importance(m);
 741 }
 742
 743 static inline u32 msg_tot_origport(struct tipc_msg *m)
 744 {
 745         if ((msg_user(m) == MSG_FRAGMENTER) && (msg_type(m) == FIRST_FRAGMENT))
 746                 return msg_origport(msg_get_wrapped(m));
 747         return msg_origport(m);
 748 }
 749
 750 struct sk_buff *tipc_buf_acquire(u32 size);
 751 bool tipc_msg_reverse(u32 own_addr, struct sk_buff *buf, u32 *dnode,
 752                       int err);
 753 int tipc_msg_eval(struct net *net, struct sk_buff *buf, u32 *dnode);
 754 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type,
 755                    u32 hsize, u32 destnode);
 756 struct sk_buff *tipc_msg_create(uint user, uint type,
 757                                 uint hdr_sz, uint data_sz, u32 dnode,
 758                                 u32 onode, u32 dport, u32 oport, int errcode);
 759 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);
 760 bool tipc_msg_bundle(struct sk_buff_head *list, struct sk_buff *skb, u32 mtu);
 761 bool tipc_msg_make_bundle(struct sk_buff_head *list,
 762                           struct sk_buff *skb, u32 mtu, u32 dnode);
 763 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
 764                    int offset, int dsz, int mtu, struct sk_buff_head *list);
 765 struct sk_buff *tipc_msg_reassemble(struct sk_buff_head *list);
 766
 767 #endif