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