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
)
49 void tipc_msg_init(struct tipc_msg
*m
, u32 user
, u32 type
, u32 hsize
,
54 msg_set_user(m
, user
);
55 msg_set_hdr_sz(m
, hsize
);
56 msg_set_size(m
, hsize
);
57 msg_set_prevnode(m
, tipc_own_addr
);
58 msg_set_type(m
, type
);
59 msg_set_orignode(m
, tipc_own_addr
);
60 msg_set_destnode(m
, destnode
);
63 /* tipc_buf_append(): Append a buffer to the fragment list of another buffer
64 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call
65 * out: set when successful non-complete reassembly, otherwise NULL
66 * @*buf: in: the buffer to append. Always defined
67 * out: head buf after sucessful complete reassembly, otherwise NULL
68 * Returns 1 when reassembly complete, otherwise 0
70 int tipc_buf_append(struct sk_buff
**headbuf
, struct sk_buff
**buf
)
72 struct sk_buff
*head
= *headbuf
;
73 struct sk_buff
*frag
= *buf
;
75 struct tipc_msg
*msg
= buf_msg(frag
);
76 u32 fragid
= msg_type(msg
);
80 skb_pull(frag
, msg_hdr_sz(msg
));
82 if (fragid
== FIRST_FRAGMENT
) {
83 if (head
|| skb_unclone(frag
, GFP_ATOMIC
))
85 head
= *headbuf
= frag
;
86 skb_frag_list_init(head
);
92 tail
= TIPC_SKB_CB(head
)->tail
;
93 if (skb_try_coalesce(head
, frag
, &headstolen
, &delta
)) {
94 kfree_skb_partial(frag
, headstolen
);
96 if (!skb_has_frag_list(head
))
97 skb_shinfo(head
)->frag_list
= frag
;
100 head
->truesize
+= frag
->truesize
;
101 head
->data_len
+= frag
->len
;
102 head
->len
+= frag
->len
;
103 TIPC_SKB_CB(head
)->tail
= frag
;
105 if (fragid
== LAST_FRAGMENT
) {
107 TIPC_SKB_CB(head
)->tail
= NULL
;
114 pr_warn_ratelimited("Unable to build fragment list\n");
117 *buf
= *headbuf
= NULL
;
123 * tipc_msg_build - create buffer chain containing specified header and data
124 * @mhdr: Message header, to be prepended to data
126 * @offset: Posision in iov to start copying from
127 * @dsz: Total length of user data
128 * @pktmax: Max packet size that can be used
129 * @chain: Buffer or chain of buffers to be returned to caller
130 * Returns message data size or errno: -ENOMEM, -EFAULT
132 int tipc_msg_build(struct tipc_msg
*mhdr
, struct iovec
const *iov
,
133 int offset
, int dsz
, int pktmax
, struct sk_buff
**chain
)
135 int mhsz
= msg_hdr_sz(mhdr
);
136 int msz
= mhsz
+ dsz
;
141 struct tipc_msg pkthdr
;
142 struct sk_buff
*buf
, *prev
;
146 msg_set_size(mhdr
, msz
);
148 /* No fragmentation needed? */
149 if (likely(msz
<= pktmax
)) {
150 buf
= tipc_buf_acquire(msz
);
154 skb_copy_to_linear_data(buf
, mhdr
, mhsz
);
155 pktpos
= buf
->data
+ mhsz
;
156 if (!dsz
|| !memcpy_fromiovecend(pktpos
, iov
, offset
, dsz
))
162 /* Prepare reusable fragment header */
163 tipc_msg_init(&pkthdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
164 INT_H_SIZE
, msg_destnode(mhdr
));
165 msg_set_size(&pkthdr
, pktmax
);
166 msg_set_fragm_no(&pkthdr
, pktno
);
168 /* Prepare first fragment */
169 *chain
= buf
= tipc_buf_acquire(pktmax
);
173 skb_copy_to_linear_data(buf
, &pkthdr
, INT_H_SIZE
);
174 pktpos
+= INT_H_SIZE
;
175 pktrem
-= INT_H_SIZE
;
176 skb_copy_to_linear_data_offset(buf
, INT_H_SIZE
, mhdr
, mhsz
);
184 if (memcpy_fromiovecend(pktpos
, iov
, offset
, pktrem
)) {
194 /* Prepare new fragment: */
195 if (drem
< (pktmax
- INT_H_SIZE
))
196 pktsz
= drem
+ INT_H_SIZE
;
200 buf
= tipc_buf_acquire(pktsz
);
206 msg_set_type(&pkthdr
, FRAGMENT
);
207 msg_set_size(&pkthdr
, pktsz
);
208 msg_set_fragm_no(&pkthdr
, ++pktno
);
209 skb_copy_to_linear_data(buf
, &pkthdr
, INT_H_SIZE
);
210 pktpos
= buf
->data
+ INT_H_SIZE
;
211 pktrem
= pktsz
- INT_H_SIZE
;
215 msg_set_type(buf_msg(buf
), LAST_FRAGMENT
);
218 kfree_skb_list(*chain
);
224 * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
225 * @bbuf: the existing buffer ("bundle")
226 * @buf: buffer to be appended
227 * @mtu: max allowable size for the bundle buffer
228 * Consumes buffer if successful
229 * Returns true if bundling could be performed, otherwise false
231 bool tipc_msg_bundle(struct sk_buff
*bbuf
, struct sk_buff
*buf
, u32 mtu
)
233 struct tipc_msg
*bmsg
= buf_msg(bbuf
);
234 struct tipc_msg
*msg
= buf_msg(buf
);
235 unsigned int bsz
= msg_size(bmsg
);
236 unsigned int msz
= msg_size(msg
);
237 u32 start
= align(bsz
);
238 u32 max
= mtu
- INT_H_SIZE
;
239 u32 pad
= start
- bsz
;
241 if (likely(msg_user(msg
) == MSG_FRAGMENTER
))
243 if (unlikely(msg_user(msg
) == CHANGEOVER_PROTOCOL
))
245 if (unlikely(msg_user(msg
) == BCAST_PROTOCOL
))
247 if (likely(msg_user(bmsg
) != MSG_BUNDLER
))
249 if (likely(msg_type(bmsg
) != BUNDLE_OPEN
))
251 if (unlikely(skb_tailroom(bbuf
) < (pad
+ msz
)))
253 if (unlikely(max
< (start
+ msz
)))
256 skb_put(bbuf
, pad
+ msz
);
257 skb_copy_to_linear_data_offset(bbuf
, start
, buf
->data
, msz
);
258 msg_set_size(bmsg
, start
+ msz
);
259 msg_set_msgcnt(bmsg
, msg_msgcnt(bmsg
) + 1);
260 bbuf
->next
= buf
->next
;
266 * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
267 * @buf: buffer to be appended and replaced
268 * @mtu: max allowable size for the bundle buffer, inclusive header
269 * @dnode: destination node for message. (Not always present in header)
270 * Replaces buffer if successful
271 * Returns true if sucess, otherwise false
273 bool tipc_msg_make_bundle(struct sk_buff
**buf
, u32 mtu
, u32 dnode
)
275 struct sk_buff
*bbuf
;
276 struct tipc_msg
*bmsg
;
277 struct tipc_msg
*msg
= buf_msg(*buf
);
278 u32 msz
= msg_size(msg
);
279 u32 max
= mtu
- INT_H_SIZE
;
281 if (msg_user(msg
) == MSG_FRAGMENTER
)
283 if (msg_user(msg
) == CHANGEOVER_PROTOCOL
)
285 if (msg_user(msg
) == BCAST_PROTOCOL
)
290 bbuf
= tipc_buf_acquire(max
);
294 skb_trim(bbuf
, INT_H_SIZE
);
295 bmsg
= buf_msg(bbuf
);
296 tipc_msg_init(bmsg
, MSG_BUNDLER
, BUNDLE_OPEN
, INT_H_SIZE
, dnode
);
297 msg_set_seqno(bmsg
, msg_seqno(msg
));
298 msg_set_ack(bmsg
, msg_ack(msg
));
299 msg_set_bcast_ack(bmsg
, msg_bcast_ack(msg
));
300 bbuf
->next
= (*buf
)->next
;
301 tipc_msg_bundle(bbuf
, *buf
, mtu
);
307 * tipc_msg_reverse(): swap source and destination addresses and add error code
308 * @buf: buffer containing message to be reversed
309 * @dnode: return value: node where to send message after reversal
310 * @err: error code to be set in message
311 * Consumes buffer if failure
312 * Returns true if success, otherwise false
314 bool tipc_msg_reverse(struct sk_buff
*buf
, u32
*dnode
, int err
)
316 struct tipc_msg
*msg
= buf_msg(buf
);
317 uint imp
= msg_importance(msg
);
318 struct tipc_msg ohdr
;
319 uint rdsz
= min_t(uint
, msg_data_sz(msg
), MAX_FORWARD_SIZE
);
321 if (skb_linearize(buf
))
323 if (msg_dest_droppable(msg
))
325 if (msg_errcode(msg
))
328 memcpy(&ohdr
, msg
, msg_hdr_sz(msg
));
329 imp
= min_t(uint
, imp
+ 1, TIPC_CRITICAL_IMPORTANCE
);
331 msg_set_importance(msg
, imp
);
332 msg_set_errcode(msg
, err
);
333 msg_set_origport(msg
, msg_destport(&ohdr
));
334 msg_set_destport(msg
, msg_origport(&ohdr
));
335 msg_set_prevnode(msg
, tipc_own_addr
);
336 if (!msg_short(msg
)) {
337 msg_set_orignode(msg
, msg_destnode(&ohdr
));
338 msg_set_destnode(msg
, msg_orignode(&ohdr
));
340 msg_set_size(msg
, msg_hdr_sz(msg
) + rdsz
);
341 skb_trim(buf
, msg_size(msg
));
343 *dnode
= msg_orignode(&ohdr
);
351 * tipc_msg_eval: determine fate of message that found no destination
352 * @buf: the buffer containing the message.
353 * @dnode: return value: next-hop node, if message to be forwarded
354 * @err: error code to use, if message to be rejected
356 * Does not consume buffer
357 * Returns 0 (TIPC_OK) if message ok and we can try again, -TIPC error
358 * code if message to be rejected
360 int tipc_msg_eval(struct sk_buff
*buf
, u32
*dnode
)
362 struct tipc_msg
*msg
= buf_msg(buf
);
365 if (msg_type(msg
) != TIPC_NAMED_MSG
)
366 return -TIPC_ERR_NO_PORT
;
367 if (skb_linearize(buf
))
368 return -TIPC_ERR_NO_NAME
;
369 if (msg_data_sz(msg
) > MAX_FORWARD_SIZE
)
370 return -TIPC_ERR_NO_NAME
;
371 if (msg_reroute_cnt(msg
) > 0)
372 return -TIPC_ERR_NO_NAME
;
374 *dnode
= addr_domain(msg_lookup_scope(msg
));
375 dport
= tipc_nametbl_translate(msg_nametype(msg
),
379 return -TIPC_ERR_NO_NAME
;
380 msg_incr_reroute_cnt(msg
);
381 msg_set_destnode(msg
, *dnode
);
382 msg_set_destport(msg
, dport
);
386 /* tipc_msg_reassemble() - clone a buffer chain of fragments and
387 * reassemble the clones into one message
389 struct sk_buff
*tipc_msg_reassemble(struct sk_buff
*chain
)
391 struct sk_buff
*buf
= chain
;
392 struct sk_buff
*frag
= buf
;
393 struct sk_buff
*head
= NULL
;
396 /* Copy header if single buffer */
398 hdr_sz
= skb_headroom(buf
) + msg_hdr_sz(buf_msg(buf
));
399 return __pskb_copy(buf
, hdr_sz
, GFP_ATOMIC
);
402 /* Clone all fragments and reassemble */
404 frag
= skb_clone(buf
, GFP_ATOMIC
);
408 if (tipc_buf_append(&head
, &frag
))
416 pr_warn("Failed do clone local mcast rcv buffer\n");
This page took 0.038529 seconds and 5 git commands to generate.