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