2 * net/tipc/msg.c: TIPC message header routines
4 * Copyright (c) 2000-2006, 2014, Ericsson AB
5 * Copyright (c) 2005, 2010-2011, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
40 #include "name_table.h"
42 #define MAX_FORWARD_SIZE 1024
44 static unsigned int align(unsigned int i
)
50 * tipc_buf_acquire - creates a TIPC message buffer
51 * @size: message size (including TIPC header)
53 * Returns a new buffer with data pointers set to the specified size.
55 * NOTE: Headroom is reserved to allow prepending of a data link header.
56 * There may also be unrequested tailroom present at the buffer's end.
58 struct sk_buff
*tipc_buf_acquire(u32 size
)
61 unsigned int buf_size
= (BUF_HEADROOM
+ size
+ 3) & ~3u;
63 skb
= alloc_skb_fclone(buf_size
, GFP_ATOMIC
);
65 skb_reserve(skb
, BUF_HEADROOM
);
72 void tipc_msg_init(struct tipc_msg
*m
, u32 user
, u32 type
, u32 hsize
,
77 msg_set_user(m
, user
);
78 msg_set_hdr_sz(m
, hsize
);
79 msg_set_size(m
, hsize
);
80 msg_set_prevnode(m
, tipc_own_addr
);
81 msg_set_type(m
, type
);
82 if (hsize
> SHORT_H_SIZE
) {
83 msg_set_orignode(m
, tipc_own_addr
);
84 msg_set_destnode(m
, destnode
);
88 struct sk_buff
*tipc_msg_create(uint user
, uint type
, uint hdr_sz
,
89 uint data_sz
, u32 dnode
, u32 onode
,
90 u32 dport
, u32 oport
, int errcode
)
95 buf
= tipc_buf_acquire(hdr_sz
+ data_sz
);
100 tipc_msg_init(msg
, user
, type
, hdr_sz
, dnode
);
101 msg_set_size(msg
, hdr_sz
+ data_sz
);
102 msg_set_prevnode(msg
, onode
);
103 msg_set_origport(msg
, oport
);
104 msg_set_destport(msg
, dport
);
105 msg_set_errcode(msg
, errcode
);
106 if (hdr_sz
> SHORT_H_SIZE
) {
107 msg_set_orignode(msg
, onode
);
108 msg_set_destnode(msg
, dnode
);
113 /* tipc_buf_append(): Append a buffer to the fragment list of another buffer
114 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call
115 * out: set when successful non-complete reassembly, otherwise NULL
116 * @*buf: in: the buffer to append. Always defined
117 * out: head buf after successful complete reassembly, otherwise NULL
118 * Returns 1 when reassembly complete, otherwise 0
120 int tipc_buf_append(struct sk_buff
**headbuf
, struct sk_buff
**buf
)
122 struct sk_buff
*head
= *headbuf
;
123 struct sk_buff
*frag
= *buf
;
124 struct sk_buff
*tail
;
125 struct tipc_msg
*msg
;
134 fragid
= msg_type(msg
);
136 skb_pull(frag
, msg_hdr_sz(msg
));
138 if (fragid
== FIRST_FRAGMENT
) {
141 if (unlikely(skb_unclone(frag
, GFP_ATOMIC
)))
143 head
= *headbuf
= frag
;
144 skb_frag_list_init(head
);
145 TIPC_SKB_CB(head
)->tail
= NULL
;
153 if (skb_try_coalesce(head
, frag
, &headstolen
, &delta
)) {
154 kfree_skb_partial(frag
, headstolen
);
156 tail
= TIPC_SKB_CB(head
)->tail
;
157 if (!skb_has_frag_list(head
))
158 skb_shinfo(head
)->frag_list
= frag
;
161 head
->truesize
+= frag
->truesize
;
162 head
->data_len
+= frag
->len
;
163 head
->len
+= frag
->len
;
164 TIPC_SKB_CB(head
)->tail
= frag
;
167 if (fragid
== LAST_FRAGMENT
) {
169 TIPC_SKB_CB(head
)->tail
= NULL
;
177 pr_warn_ratelimited("Unable to build fragment list\n");
180 *buf
= *headbuf
= NULL
;
186 * tipc_msg_build - create buffer chain containing specified header and data
187 * @mhdr: Message header, to be prepended to data
189 * @offset: Posision in iov to start copying from
190 * @dsz: Total length of user data
191 * @pktmax: Max packet size that can be used
192 * @list: Buffer or chain of buffers to be returned to caller
194 * Returns message data size or errno: -ENOMEM, -EFAULT
196 int tipc_msg_build(struct tipc_msg
*mhdr
, struct msghdr
*m
, int offset
,
197 int dsz
, int pktmax
, struct sk_buff_head
*list
)
199 int mhsz
= msg_hdr_sz(mhdr
);
200 int msz
= mhsz
+ dsz
;
205 struct tipc_msg pkthdr
;
210 msg_set_size(mhdr
, msz
);
212 /* No fragmentation needed? */
213 if (likely(msz
<= pktmax
)) {
214 skb
= tipc_buf_acquire(msz
);
217 __skb_queue_tail(list
, skb
);
218 skb_copy_to_linear_data(skb
, mhdr
, mhsz
);
219 pktpos
= skb
->data
+ mhsz
;
220 if (!dsz
|| !memcpy_fromiovecend(pktpos
, m
->msg_iter
.iov
, offset
,
227 /* Prepare reusable fragment header */
228 tipc_msg_init(&pkthdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
229 INT_H_SIZE
, msg_destnode(mhdr
));
230 msg_set_size(&pkthdr
, pktmax
);
231 msg_set_fragm_no(&pkthdr
, pktno
);
233 /* Prepare first fragment */
234 skb
= tipc_buf_acquire(pktmax
);
237 __skb_queue_tail(list
, skb
);
239 skb_copy_to_linear_data(skb
, &pkthdr
, INT_H_SIZE
);
240 pktpos
+= INT_H_SIZE
;
241 pktrem
-= INT_H_SIZE
;
242 skb_copy_to_linear_data_offset(skb
, INT_H_SIZE
, mhdr
, mhsz
);
250 if (memcpy_fromiovecend(pktpos
, m
->msg_iter
.iov
, offset
, pktrem
)) {
260 /* Prepare new fragment: */
261 if (drem
< (pktmax
- INT_H_SIZE
))
262 pktsz
= drem
+ INT_H_SIZE
;
265 skb
= tipc_buf_acquire(pktsz
);
270 __skb_queue_tail(list
, skb
);
271 msg_set_type(&pkthdr
, FRAGMENT
);
272 msg_set_size(&pkthdr
, pktsz
);
273 msg_set_fragm_no(&pkthdr
, ++pktno
);
274 skb_copy_to_linear_data(skb
, &pkthdr
, INT_H_SIZE
);
275 pktpos
= skb
->data
+ INT_H_SIZE
;
276 pktrem
= pktsz
- INT_H_SIZE
;
279 msg_set_type(buf_msg(skb
), LAST_FRAGMENT
);
282 __skb_queue_purge(list
);
283 __skb_queue_head_init(list
);
288 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
289 * @list: the buffer chain of the existing buffer ("bundle")
290 * @skb: buffer to be appended
291 * @mtu: max allowable size for the bundle buffer
292 * Consumes buffer if successful
293 * Returns true if bundling could be performed, otherwise false
295 bool tipc_msg_bundle(struct sk_buff_head
*list
, struct sk_buff
*skb
, u32 mtu
)
297 struct sk_buff
*bskb
= skb_peek_tail(list
);
298 struct tipc_msg
*bmsg
= buf_msg(bskb
);
299 struct tipc_msg
*msg
= buf_msg(skb
);
300 unsigned int bsz
= msg_size(bmsg
);
301 unsigned int msz
= msg_size(msg
);
302 u32 start
= align(bsz
);
303 u32 max
= mtu
- INT_H_SIZE
;
304 u32 pad
= start
- bsz
;
306 if (likely(msg_user(msg
) == MSG_FRAGMENTER
))
308 if (unlikely(msg_user(msg
) == CHANGEOVER_PROTOCOL
))
310 if (unlikely(msg_user(msg
) == BCAST_PROTOCOL
))
312 if (likely(msg_user(bmsg
) != MSG_BUNDLER
))
314 if (likely(!TIPC_SKB_CB(bskb
)->bundling
))
316 if (unlikely(skb_tailroom(bskb
) < (pad
+ msz
)))
318 if (unlikely(max
< (start
+ msz
)))
321 skb_put(bskb
, pad
+ msz
);
322 skb_copy_to_linear_data_offset(bskb
, start
, skb
->data
, msz
);
323 msg_set_size(bmsg
, start
+ msz
);
324 msg_set_msgcnt(bmsg
, msg_msgcnt(bmsg
) + 1);
330 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
331 * @list: the buffer chain
332 * @skb: buffer to be appended and replaced
333 * @mtu: max allowable size for the bundle buffer, inclusive header
334 * @dnode: destination node for message. (Not always present in header)
335 * Replaces buffer if successful
336 * Returns true if success, otherwise false
338 bool tipc_msg_make_bundle(struct sk_buff_head
*list
, struct sk_buff
*skb
,
341 struct sk_buff
*bskb
;
342 struct tipc_msg
*bmsg
;
343 struct tipc_msg
*msg
= buf_msg(skb
);
344 u32 msz
= msg_size(msg
);
345 u32 max
= mtu
- INT_H_SIZE
;
347 if (msg_user(msg
) == MSG_FRAGMENTER
)
349 if (msg_user(msg
) == CHANGEOVER_PROTOCOL
)
351 if (msg_user(msg
) == BCAST_PROTOCOL
)
356 bskb
= tipc_buf_acquire(max
);
360 skb_trim(bskb
, INT_H_SIZE
);
361 bmsg
= buf_msg(bskb
);
362 tipc_msg_init(bmsg
, MSG_BUNDLER
, 0, INT_H_SIZE
, dnode
);
363 msg_set_seqno(bmsg
, msg_seqno(msg
));
364 msg_set_ack(bmsg
, msg_ack(msg
));
365 msg_set_bcast_ack(bmsg
, msg_bcast_ack(msg
));
366 TIPC_SKB_CB(bskb
)->bundling
= true;
367 __skb_queue_tail(list
, bskb
);
368 return tipc_msg_bundle(list
, skb
, mtu
);
372 * tipc_msg_reverse(): swap source and destination addresses and add error code
373 * @buf: buffer containing message to be reversed
374 * @dnode: return value: node where to send message after reversal
375 * @err: error code to be set in message
376 * Consumes buffer if failure
377 * Returns true if success, otherwise false
379 bool tipc_msg_reverse(struct sk_buff
*buf
, u32
*dnode
, int err
)
381 struct tipc_msg
*msg
= buf_msg(buf
);
382 uint imp
= msg_importance(msg
);
383 struct tipc_msg ohdr
;
384 uint rdsz
= min_t(uint
, msg_data_sz(msg
), MAX_FORWARD_SIZE
);
386 if (skb_linearize(buf
))
388 if (msg_dest_droppable(msg
))
390 if (msg_errcode(msg
))
393 memcpy(&ohdr
, msg
, msg_hdr_sz(msg
));
394 imp
= min_t(uint
, imp
+ 1, TIPC_CRITICAL_IMPORTANCE
);
396 msg_set_importance(msg
, imp
);
397 msg_set_errcode(msg
, err
);
398 msg_set_origport(msg
, msg_destport(&ohdr
));
399 msg_set_destport(msg
, msg_origport(&ohdr
));
400 msg_set_prevnode(msg
, tipc_own_addr
);
401 if (!msg_short(msg
)) {
402 msg_set_orignode(msg
, msg_destnode(&ohdr
));
403 msg_set_destnode(msg
, msg_orignode(&ohdr
));
405 msg_set_size(msg
, msg_hdr_sz(msg
) + rdsz
);
406 skb_trim(buf
, msg_size(msg
));
408 *dnode
= msg_orignode(&ohdr
);
416 * tipc_msg_eval: determine fate of message that found no destination
417 * @buf: the buffer containing the message.
418 * @dnode: return value: next-hop node, if message to be forwarded
419 * @err: error code to use, if message to be rejected
421 * Does not consume buffer
422 * Returns 0 (TIPC_OK) if message ok and we can try again, -TIPC error
423 * code if message to be rejected
425 int tipc_msg_eval(struct sk_buff
*buf
, u32
*dnode
)
427 struct tipc_msg
*msg
= buf_msg(buf
);
430 if (msg_type(msg
) != TIPC_NAMED_MSG
)
431 return -TIPC_ERR_NO_PORT
;
432 if (skb_linearize(buf
))
433 return -TIPC_ERR_NO_NAME
;
434 if (msg_data_sz(msg
) > MAX_FORWARD_SIZE
)
435 return -TIPC_ERR_NO_NAME
;
436 if (msg_reroute_cnt(msg
) > 0)
437 return -TIPC_ERR_NO_NAME
;
439 *dnode
= addr_domain(msg_lookup_scope(msg
));
440 dport
= tipc_nametbl_translate(msg_nametype(msg
),
444 return -TIPC_ERR_NO_NAME
;
445 msg_incr_reroute_cnt(msg
);
446 msg_set_destnode(msg
, *dnode
);
447 msg_set_destport(msg
, dport
);
451 /* tipc_msg_reassemble() - clone a buffer chain of fragments and
452 * reassemble the clones into one message
454 struct sk_buff
*tipc_msg_reassemble(struct sk_buff_head
*list
)
457 struct sk_buff
*frag
= NULL
;
458 struct sk_buff
*head
= NULL
;
461 /* Copy header if single buffer */
462 if (skb_queue_len(list
) == 1) {
463 skb
= skb_peek(list
);
464 hdr_sz
= skb_headroom(skb
) + msg_hdr_sz(buf_msg(skb
));
465 return __pskb_copy(skb
, hdr_sz
, GFP_ATOMIC
);
468 /* Clone all fragments and reassemble */
469 skb_queue_walk(list
, skb
) {
470 frag
= skb_clone(skb
, GFP_ATOMIC
);
474 if (tipc_buf_append(&head
, &frag
))
481 pr_warn("Failed do clone local mcast rcv buffer\n");
This page took 0.040738 seconds and 6 git commands to generate.