xref: /openbmc/linux/net/sctp/chunk.c (revision b6dcefde)
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 #include <linux/types.h>
41 #include <linux/kernel.h>
42 #include <linux/net.h>
43 #include <linux/inet.h>
44 #include <linux/skbuff.h>
45 #include <net/sock.h>
46 #include <net/sctp/sctp.h>
47 #include <net/sctp/sm.h>
48 
49 /* This file is mostly in anticipation of future work, but initially
50  * populate with fragment tracking for an outbound message.
51  */
52 
53 /* Initialize datamsg from memory. */
54 static void sctp_datamsg_init(struct sctp_datamsg *msg)
55 {
56 	atomic_set(&msg->refcnt, 1);
57 	msg->send_failed = 0;
58 	msg->send_error = 0;
59 	msg->can_abandon = 0;
60 	msg->expires_at = 0;
61 	INIT_LIST_HEAD(&msg->chunks);
62 	msg->msg_size = 0;
63 }
64 
65 /* Allocate and initialize datamsg. */
66 SCTP_STATIC struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp)
67 {
68 	struct sctp_datamsg *msg;
69 	msg = kmalloc(sizeof(struct sctp_datamsg), gfp);
70 	if (msg) {
71 		sctp_datamsg_init(msg);
72 		SCTP_DBG_OBJCNT_INC(datamsg);
73 	}
74 	return msg;
75 }
76 
77 void sctp_datamsg_free(struct sctp_datamsg *msg)
78 {
79 	struct sctp_chunk *chunk;
80 
81 	/* This doesn't have to be a _safe vairant because
82 	 * sctp_chunk_free() only drops the refs.
83 	 */
84 	list_for_each_entry(chunk, &msg->chunks, frag_list)
85 		sctp_chunk_free(chunk);
86 
87 	sctp_datamsg_put(msg);
88 }
89 
90 /* Final destructruction of datamsg memory. */
91 static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
92 {
93 	struct list_head *pos, *temp;
94 	struct sctp_chunk *chunk;
95 	struct sctp_sock *sp;
96 	struct sctp_ulpevent *ev;
97 	struct sctp_association *asoc = NULL;
98 	int error = 0, notify;
99 
100 	/* If we failed, we may need to notify. */
101 	notify = msg->send_failed ? -1 : 0;
102 
103 	/* Release all references. */
104 	list_for_each_safe(pos, temp, &msg->chunks) {
105 		list_del_init(pos);
106 		chunk = list_entry(pos, struct sctp_chunk, frag_list);
107 		/* Check whether we _really_ need to notify. */
108 		if (notify < 0) {
109 			asoc = chunk->asoc;
110 			if (msg->send_error)
111 				error = msg->send_error;
112 			else
113 				error = asoc->outqueue.error;
114 
115 			sp = sctp_sk(asoc->base.sk);
116 			notify = sctp_ulpevent_type_enabled(SCTP_SEND_FAILED,
117 							    &sp->subscribe);
118 		}
119 
120 		/* Generate a SEND FAILED event only if enabled. */
121 		if (notify > 0) {
122 			int sent;
123 			if (chunk->has_tsn)
124 				sent = SCTP_DATA_SENT;
125 			else
126 				sent = SCTP_DATA_UNSENT;
127 
128 			ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent,
129 							    error, GFP_ATOMIC);
130 			if (ev)
131 				sctp_ulpq_tail_event(&asoc->ulpq, ev);
132 		}
133 
134 		sctp_chunk_put(chunk);
135 	}
136 
137 	SCTP_DBG_OBJCNT_DEC(datamsg);
138 	kfree(msg);
139 }
140 
141 /* Hold a reference. */
142 static void sctp_datamsg_hold(struct sctp_datamsg *msg)
143 {
144 	atomic_inc(&msg->refcnt);
145 }
146 
147 /* Release a reference. */
148 void sctp_datamsg_put(struct sctp_datamsg *msg)
149 {
150 	if (atomic_dec_and_test(&msg->refcnt))
151 		sctp_datamsg_destroy(msg);
152 }
153 
154 /* Assign a chunk to this datamsg. */
155 static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk)
156 {
157 	sctp_datamsg_hold(msg);
158 	chunk->msg = msg;
159 	msg->msg_size += chunk->skb->len;
160 }
161 
162 
163 /* A data chunk can have a maximum payload of (2^16 - 20).  Break
164  * down any such message into smaller chunks.  Opportunistically, fragment
165  * the chunks down to the current MTU constraints.  We may get refragmented
166  * later if the PMTU changes, but it is _much better_ to fragment immediately
167  * with a reasonable guess than always doing our fragmentation on the
168  * soft-interrupt.
169  */
170 struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
171 					    struct sctp_sndrcvinfo *sinfo,
172 					    struct msghdr *msgh, int msg_len)
173 {
174 	int max, whole, i, offset, over, err;
175 	int len, first_len;
176 	int max_data;
177 	struct sctp_chunk *chunk;
178 	struct sctp_datamsg *msg;
179 	struct list_head *pos, *temp;
180 	__u8 frag;
181 
182 	msg = sctp_datamsg_new(GFP_KERNEL);
183 	if (!msg)
184 		return NULL;
185 
186 	/* Note: Calculate this outside of the loop, so that all fragments
187 	 * have the same expiration.
188 	 */
189 	if (sinfo->sinfo_timetolive) {
190 		/* sinfo_timetolive is in milliseconds */
191 		msg->expires_at = jiffies +
192 				    msecs_to_jiffies(sinfo->sinfo_timetolive);
193 		msg->can_abandon = 1;
194 		SCTP_DEBUG_PRINTK("%s: msg:%p expires_at: %ld jiffies:%ld\n",
195 				  __func__, msg, msg->expires_at, jiffies);
196 	}
197 
198 	/* This is the biggest possible DATA chunk that can fit into
199 	 * the packet
200 	 */
201 	max_data = asoc->pathmtu -
202 		sctp_sk(asoc->base.sk)->pf->af->net_header_len -
203 		sizeof(struct sctphdr) - sizeof(struct sctp_data_chunk);
204 
205 	max = asoc->frag_point;
206 	/* If the the peer requested that we authenticate DATA chunks
207 	 * we need to accound for bundling of the AUTH chunks along with
208 	 * DATA.
209 	 */
210 	if (sctp_auth_send_cid(SCTP_CID_DATA, asoc)) {
211 		struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc);
212 
213 		if (hmac_desc)
214 			max_data -= WORD_ROUND(sizeof(sctp_auth_chunk_t) +
215 					    hmac_desc->hmac_len);
216 	}
217 
218 	/* Now, check if we need to reduce our max */
219 	if (max > max_data)
220 		max = max_data;
221 
222 	whole = 0;
223 	first_len = max;
224 
225 	/* Check to see if we have a pending SACK and try to let it be bundled
226 	 * with this message.  Do this if we don't have any data queued already.
227 	 * To check that, look at out_qlen and retransmit list.
228 	 * NOTE: we will not reduce to account for SACK, if the message would
229 	 * not have been fragmented.
230 	 */
231 	if (timer_pending(&asoc->timers[SCTP_EVENT_TIMEOUT_SACK]) &&
232 	    asoc->outqueue.out_qlen == 0 &&
233 	    list_empty(&asoc->outqueue.retransmit) &&
234 	    msg_len > max)
235 		max_data -= WORD_ROUND(sizeof(sctp_sack_chunk_t));
236 
237 	/* Encourage Cookie-ECHO bundling. */
238 	if (asoc->state < SCTP_STATE_COOKIE_ECHOED)
239 		max_data -= SCTP_ARBITRARY_COOKIE_ECHO_LEN;
240 
241 	/* Now that we adjusted completely, reset first_len */
242 	if (first_len > max_data)
243 		first_len = max_data;
244 
245 	/* Account for a different sized first fragment */
246 	if (msg_len >= first_len) {
247 		msg_len -= first_len;
248 		whole = 1;
249 	}
250 
251 	/* How many full sized?  How many bytes leftover? */
252 	whole += msg_len / max;
253 	over = msg_len % max;
254 	offset = 0;
255 
256 	if ((whole > 1) || (whole && over))
257 		SCTP_INC_STATS_USER(SCTP_MIB_FRAGUSRMSGS);
258 
259 	/* Create chunks for all the full sized DATA chunks. */
260 	for (i=0, len=first_len; i < whole; i++) {
261 		frag = SCTP_DATA_MIDDLE_FRAG;
262 
263 		if (0 == i)
264 			frag |= SCTP_DATA_FIRST_FRAG;
265 
266 		if ((i == (whole - 1)) && !over) {
267 			frag |= SCTP_DATA_LAST_FRAG;
268 
269 			/* The application requests to set the I-bit of the
270 			 * last DATA chunk of a user message when providing
271 			 * the user message to the SCTP implementation.
272 			 */
273 			if ((sinfo->sinfo_flags & SCTP_EOF) ||
274 			    (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
275 				frag |= SCTP_DATA_SACK_IMM;
276 		}
277 
278 		chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag, 0);
279 
280 		if (!chunk)
281 			goto errout;
282 		err = sctp_user_addto_chunk(chunk, offset, len, msgh->msg_iov);
283 		if (err < 0)
284 			goto errout;
285 
286 		offset += len;
287 
288 		/* Put the chunk->skb back into the form expected by send.  */
289 		__skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
290 			   - (__u8 *)chunk->skb->data);
291 
292 		sctp_datamsg_assign(msg, chunk);
293 		list_add_tail(&chunk->frag_list, &msg->chunks);
294 
295 		/* The first chunk, the first chunk was likely short
296 		 * to allow bundling, so reset to full size.
297 		 */
298 		if (0 == i)
299 			len = max;
300 	}
301 
302 	/* .. now the leftover bytes. */
303 	if (over) {
304 		if (!whole)
305 			frag = SCTP_DATA_NOT_FRAG;
306 		else
307 			frag = SCTP_DATA_LAST_FRAG;
308 
309 		if ((sinfo->sinfo_flags & SCTP_EOF) ||
310 		    (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
311 			frag |= SCTP_DATA_SACK_IMM;
312 
313 		chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag, 0);
314 
315 		if (!chunk)
316 			goto errout;
317 
318 		err = sctp_user_addto_chunk(chunk, offset, over,msgh->msg_iov);
319 
320 		/* Put the chunk->skb back into the form expected by send.  */
321 		__skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr
322 			   - (__u8 *)chunk->skb->data);
323 		if (err < 0)
324 			goto errout;
325 
326 		sctp_datamsg_assign(msg, chunk);
327 		list_add_tail(&chunk->frag_list, &msg->chunks);
328 	}
329 
330 	return msg;
331 
332 errout:
333 	list_for_each_safe(pos, temp, &msg->chunks) {
334 		list_del_init(pos);
335 		chunk = list_entry(pos, struct sctp_chunk, frag_list);
336 		sctp_chunk_free(chunk);
337 	}
338 	sctp_datamsg_put(msg);
339 	return NULL;
340 }
341 
342 /* Check whether this message has expired. */
343 int sctp_chunk_abandoned(struct sctp_chunk *chunk)
344 {
345 	struct sctp_datamsg *msg = chunk->msg;
346 
347 	if (!msg->can_abandon)
348 		return 0;
349 
350 	if (time_after(jiffies, msg->expires_at))
351 		return 1;
352 
353 	return 0;
354 }
355 
356 /* This chunk (and consequently entire message) has failed in its sending. */
357 void sctp_chunk_fail(struct sctp_chunk *chunk, int error)
358 {
359 	chunk->msg->send_failed = 1;
360 	chunk->msg->send_error = error;
361 }
362