~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sctp/chunk.c

Version: ~ [ linux-5.2-rc5 ] ~ [ linux-5.1.12 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.53 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.128 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.182 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.182 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SCTP kernel implementation
  2  * (C) Copyright IBM Corp. 2003, 2004
  3  *
  4  * This file is part of the SCTP kernel implementation
  5  *
  6  * This file contains the code relating the chunk abstraction.
  7  *
  8  * This SCTP implementation is free software;
  9  * you can redistribute it and/or modify it under the terms of
 10  * the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2, or (at your option)
 12  * any later version.
 13  *
 14  * This SCTP implementation is distributed in the hope that it
 15  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
 16  *                 ************************
 17  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 18  * See the GNU General Public License for more details.
 19  *
 20  * You should have received a copy of the GNU General Public License
 21  * along with GNU CC; see the file COPYING.  If not, write to
 22  * the Free Software Foundation, 59 Temple Place - Suite 330,
 23  * Boston, MA 02111-1307, USA.
 24  *
 25  * Please send any bug reports or fixes you make to the
 26  * email address(es):
 27  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
 28  *
 29  * Or submit a bug report through the following website:
 30  *    http://www.sf.net/projects/lksctp
 31  *
 32  * Written or modified by:
 33  *    Jon Grimm             <jgrimm@us.ibm.com>
 34  *    Sridhar Samudrala     <sri@us.ibm.com>
 35  *
 36  * Any bugs reported given to us we will try to fix... any fixes shared will
 37  * be incorporated into the next SCTP release.
 38  */
 39 
 40 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 41 
 42 #include <linux/types.h>
 43 #include <linux/kernel.h>
 44 #include <linux/net.h>
 45 #include <linux/inet.h>
 46 #include <linux/skbuff.h>
 47 #include <linux/slab.h>
 48 #include <net/sock.h>
 49 #include <net/sctp/sctp.h>
 50 #include <net/sctp/sm.h>
 51 
 52 /* This file is mostly in anticipation of future work, but initially
 53  * populate with fragment tracking for an outbound message.
 54  */
 55 
 56 /* Initialize datamsg from memory. */
 57 static void sctp_datamsg_init(struct sctp_datamsg *msg)
 58 {
 59         atomic_set(&msg->refcnt, 1);
 60         msg->send_failed = 0;
 61         msg->send_error = 0;
 62         msg->can_abandon = 0;
 63         msg->can_delay = 1;
 64         msg->expires_at = 0;
 65         INIT_LIST_HEAD(&msg->chunks);
 66 }
 67 
 68 /* Allocate and initialize datamsg. */
 69 static struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp)
 70 {
 71         struct sctp_datamsg *msg;
 72         msg = kmalloc(sizeof(struct sctp_datamsg), gfp);
 73         if (msg) {
 74                 sctp_datamsg_init(msg);
 75                 SCTP_DBG_OBJCNT_INC(datamsg);
 76         }
 77         return msg;
 78 }
 79 
 80 void sctp_datamsg_free(struct sctp_datamsg *msg)
 81 {
 82         struct sctp_chunk *chunk;
 83 
 84         /* This doesn't have to be a _safe vairant because
 85          * sctp_chunk_free() only drops the refs.
 86          */
 87         list_for_each_entry(chunk, &msg->chunks, frag_list)
 88                 sctp_chunk_free(chunk);
 89 
 90         sctp_datamsg_put(msg);
 91 }
 92 
 93 /* Final destructruction of datamsg memory. */
 94 static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
 95 {
 96         struct list_head *pos, *temp;
 97         struct sctp_chunk *chunk;
 98         struct sctp_sock *sp;
 99         struct sctp_ulpevent *ev;
100         struct sctp_association *asoc = NULL;
101         int error = 0, notify;
102 
103         /* If we failed, we may need to notify. */
104         notify = msg->send_failed ? -1 : 0;
105 
106         /* Release all references. */
107         list_for_each_safe(pos, temp, &msg->chunks) {
108                 list_del_init(pos);
109                 chunk = list_entry(pos, struct sctp_chunk, frag_list);
110                 /* Check whether we _really_ need to notify. */
111                 if (notify < 0) {
112                         asoc = chunk->asoc;
113                         if (msg->send_error)
114                                 error = msg->send_error;
115                         else
116                                 error = asoc->outqueue.error;
117 
118                         sp = sctp_sk(asoc->base.sk);
119                         notify = sctp_ulpevent_type_enabled(SCTP_SEND_FAILED,
120                                                             &sp->subscribe);
121                 }
122 
123                 /* Generate a SEND FAILED event only if enabled. */
124                 if (notify > 0) {
125                         int sent;
126                         if (chunk->has_tsn)
127                                 sent = SCTP_DATA_SENT;
128                         else
129                                 sent = SCTP_DATA_UNSENT;
130 
131                         ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent,
132                                                             error, GFP_ATOMIC);
133                         if (ev)
134                                 sctp_ulpq_tail_event(&asoc->ulpq, ev);
135                 }
136 
137                 sctp_chunk_put(chunk);
138         }
139 
140         SCTP_DBG_OBJCNT_DEC(datamsg);
141         kfree(msg);
142 }
143 
144 /* Hold a reference. */
145 static void sctp_datamsg_hold(struct sctp_datamsg *msg)
146 {
147         atomic_inc(&msg->refcnt);
148 }
149 
150 /* Release a reference. */
151 void sctp_datamsg_put(struct sctp_datamsg *msg)
152 {
153         if (atomic_dec_and_test(&msg->refcnt))
154                 sctp_datamsg_destroy(msg);
155 }
156 
157 /* Assign a chunk to this datamsg. */
158 static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk)
159 {
160         sctp_datamsg_hold(msg);
161         chunk->msg = msg;
162 }
163 
164 
165 /* A data chunk can have a maximum payload of (2^16 - 20).  Break
166  * down any such message into smaller chunks.  Opportunistically, fragment
167  * the chunks down to the current MTU constraints.  We may get refragmented
168  * later if the PMTU changes, but it is _much better_ to fragment immediately
169  * with a reasonable guess than always doing our fragmentation on the
170  * soft-interrupt.
171  */
172 struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
173                                             struct sctp_sndrcvinfo *sinfo,
174                                             struct msghdr *msgh, int msg_len)
175 {
176         int max, whole, i, offset, over, err;
177         int len, first_len;
178         int max_data;
179         struct sctp_chunk *chunk;
180         struct sctp_datamsg *msg;
181         struct list_head *pos, *temp;
182         __u8 frag;
183 
184         msg = sctp_datamsg_new(GFP_KERNEL);
185         if (!msg)
186                 return ERR_PTR(-ENOMEM);
187 
188         /* Note: Calculate this outside of the loop, so that all fragments
189          * have the same expiration.
190          */
191         if (sinfo->sinfo_timetolive) {
192                 /* sinfo_timetolive is in milliseconds */
193                 msg->expires_at = jiffies +
194                                     msecs_to_jiffies(sinfo->sinfo_timetolive);
195                 msg->can_abandon = 1;
196 
197                 pr_debug("%s: msg:%p expires_at:%ld jiffies:%ld\n", __func__,
198                          msg, msg->expires_at, jiffies);
199         }
200 
201         /* This is the biggest possible DATA chunk that can fit into
202          * the packet
203          */
204         max_data = asoc->pathmtu -
205                 sctp_sk(asoc->base.sk)->pf->af->net_header_len -
206                 sizeof(struct sctphdr) - sizeof(struct sctp_data_chunk);
207 
208         max = asoc->frag_point;
209         /* If the the peer requested that we authenticate DATA chunks
210          * we need to accound for bundling of the AUTH chunks along with
211          * DATA.
212          */
213         if (sctp_auth_send_cid(SCTP_CID_DATA, asoc)) {
214                 struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc);
215 
216                 if (hmac_desc)
217                         max_data -= WORD_ROUND(sizeof(sctp_auth_chunk_t) +
218                                             hmac_desc->hmac_len);
219         }
220 
221         /* Now, check if we need to reduce our max */
222         if (max > max_data)
223                 max = max_data;
224 
225         whole = 0;
226         first_len = max;
227 
228         /* Check to see if we have a pending SACK and try to let it be bundled
229          * with this message.  Do this if we don't have any data queued already.
230          * To check that, look at out_qlen and retransmit list.
231          * NOTE: we will not reduce to account for SACK, if the message would
232          * not have been fragmented.
233          */
234         if (timer_pending(&asoc->timers[SCTP_EVENT_TIMEOUT_SACK]) &&
235             asoc->outqueue.out_qlen == 0 &&
236             list_empty(&asoc->outqueue.retransmit) &&
237             msg_len > max)
238                 max_data -= WORD_ROUND(sizeof(sctp_sack_chunk_t));
239 
240         /* Encourage Cookie-ECHO bundling. */
241         if (asoc->state < SCTP_STATE_COOKIE_ECHOED)
242                 max_data -= SCTP_ARBITRARY_COOKIE_ECHO_LEN;
243 
244         /* Now that we adjusted completely, reset first_len */
245         if (first_len > max_data)
246                 first_len = max_data;
247 
248         /* Account for a different sized first fragment */
249         if (msg_len >= first_len) {
250                 msg_len -= first_len;
251                 whole = 1;
252                 msg->can_delay = 0;
253         }
254 
255         /* How many full sized?  How many bytes leftover? */
256         whole += msg_len / max;
257         over = msg_len % max;
258         offset = 0;
259 
260         if ((whole > 1) || (whole && over))
261                 SCTP_INC_STATS_USER(sock_net(asoc->base.sk), SCTP_MIB_FRAGUSRMSGS);
262 
263         /* Create chunks for all the full sized DATA chunks. */
264         for (i=0, len=first_len; i < whole; i++) {
265                 frag = SCTP_DATA_MIDDLE_FRAG;
266 
267                 if (0 == i)
268                         frag |= SCTP_DATA_FIRST_FRAG;
269 
270                 if ((i == (whole - 1)) && !over) {
271                         frag |= SCTP_DATA_LAST_FRAG;
272 
273                         /* The application requests to set the I-bit of the
274                          * last DATA chunk of a user message when providing
275                          * the user message to the SCTP implementation.
276                          */
277                         if ((sinfo->sinfo_flags & SCTP_EOF) ||
278                             (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
279                                 frag |= SCTP_DATA_SACK_IMM;
280                 }
281 
282                 chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag, 0);
283 
284                 if (!chunk) {
285                         err = -ENOMEM;
286                         goto errout;
287                 }
288 
289                 err = sctp_user_addto_chunk(chunk, offset, len, msgh->msg_iov);
290                 if (err < 0)
291                         goto errout_chunk_free;
292 
293                 offset += len;
294 
295                 /* Put the chunk->skb back into the form expected by send.  */
296                 __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
297                            - (__u8 *)chunk->skb->data);
298 
299                 sctp_datamsg_assign(msg, chunk);
300                 list_add_tail(&chunk->frag_list, &msg->chunks);
301 
302                 /* The first chunk, the first chunk was likely short
303                  * to allow bundling, so reset to full size.
304                  */
305                 if (0 == i)
306                         len = max;
307         }
308 
309         /* .. now the leftover bytes. */
310         if (over) {
311                 if (!whole)
312                         frag = SCTP_DATA_NOT_FRAG;
313                 else
314                         frag = SCTP_DATA_LAST_FRAG;
315 
316                 if ((sinfo->sinfo_flags & SCTP_EOF) ||
317                     (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
318                         frag |= SCTP_DATA_SACK_IMM;
319 
320                 chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag, 0);
321 
322                 if (!chunk) {
323                         err = -ENOMEM;
324                         goto errout;
325                 }
326 
327                 err = sctp_user_addto_chunk(chunk, offset, over,msgh->msg_iov);
328 
329                 /* Put the chunk->skb back into the form expected by send.  */
330                 __skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
331                            - (__u8 *)chunk->skb->data);
332                 if (err < 0)
333                         goto errout_chunk_free;
334 
335                 sctp_datamsg_assign(msg, chunk);
336                 list_add_tail(&chunk->frag_list, &msg->chunks);
337         }
338 
339         return msg;
340 
341 errout_chunk_free:
342         sctp_chunk_free(chunk);
343 
344 errout:
345         list_for_each_safe(pos, temp, &msg->chunks) {
346                 list_del_init(pos);
347                 chunk = list_entry(pos, struct sctp_chunk, frag_list);
348                 sctp_chunk_free(chunk);
349         }
350         sctp_datamsg_put(msg);
351         return ERR_PTR(err);
352 }
353 
354 /* Check whether this message has expired. */
355 int sctp_chunk_abandoned(struct sctp_chunk *chunk)
356 {
357         struct sctp_datamsg *msg = chunk->msg;
358 
359         if (!msg->can_abandon)
360                 return 0;
361 
362         if (time_after(jiffies, msg->expires_at))
363                 return 1;
364 
365         return 0;
366 }
367 
368 /* This chunk (and consequently entire message) has failed in its sending. */
369 void sctp_chunk_fail(struct sctp_chunk *chunk, int error)
370 {
371         chunk->msg->send_failed = 1;
372         chunk->msg->send_error = error;
373 }
374 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp