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