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