[linux-block.git] / net / sctp / tsnmap.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* SCTP kernel implementation
 * (C) Copyright IBM Corp. 2001, 2004
 * Copyright (c) 1999-2000 Cisco, Inc.
 * Copyright (c) 1999-2001 Motorola, Inc.
 * Copyright (c) 2001 Intel Corp.
 *
 * This file is part of the SCTP kernel implementation
 *
 * These functions manipulate sctp tsn mapping array.
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
 *    lksctp developers <linux-sctp@vger.kernel.org>
 *
 * Written or modified by:
 *    La Monte H.P. Yarroll <piggy@acm.org>
 *    Jon Grimm             <jgrimm@us.ibm.com>
 *    Karl Knutson          <karl@athena.chicago.il.us>
 *    Sridhar Samudrala     <sri@us.ibm.com>
 */

#include <linux/slab.h>
#include <linux/types.h>
#include <linux/bitmap.h>
#include <net/sctp/sctp.h>
#include <net/sctp/sm.h>

static void sctp_tsnmap_update(struct sctp_tsnmap *map);
static void sctp_tsnmap_find_gap_ack(unsigned long *map, __u16 off,
				     __u16 len, __u16 *start, __u16 *end);
static int sctp_tsnmap_grow(struct sctp_tsnmap *map, u16 size);

/* Initialize a block of memory as a tsnmap.  */
struct sctp_tsnmap *sctp_tsnmap_init(struct sctp_tsnmap *map, __u16 len,
				     __u32 initial_tsn, gfp_t gfp)
{
	if (!map->tsn_map) {
		map->tsn_map = kzalloc(len>>3, gfp);
		if (map->tsn_map == NULL)
			return NULL;

		map->len = len;
	} else {
		bitmap_zero(map->tsn_map, map->len);
	}

	/* Keep track of TSNs represented by tsn_map.  */
	map->base_tsn = initial_tsn;
	map->cumulative_tsn_ack_point = initial_tsn - 1;
	map->max_tsn_seen = map->cumulative_tsn_ack_point;
	map->num_dup_tsns = 0;

	return map;
}

void sctp_tsnmap_free(struct sctp_tsnmap *map)
{
	map->len = 0;
	kfree(map->tsn_map);
}

/* Test the tracking state of this TSN.
 * Returns:
 *   0 if the TSN has not yet been seen
 *  >0 if the TSN has been seen (duplicate)
 *  <0 if the TSN is invalid (too large to track)
 */
int sctp_tsnmap_check(const struct sctp_tsnmap *map, __u32 tsn)
{
	u32 gap;

	/* Check to see if this is an old TSN */
	if (TSN_lte(tsn, map->cumulative_tsn_ack_point))
		return 1;

	/* Verify that we can hold this TSN and that it will not
	 * overflow our map
	 */
	if (!TSN_lt(tsn, map->base_tsn + SCTP_TSN_MAP_SIZE))
		return -1;

	/* Calculate the index into the mapping arrays.  */
	gap = tsn - map->base_tsn;

	/* Check to see if TSN has already been recorded.  */
	if (gap < map->len && test_bit(gap, map->tsn_map))
		return 1;
	else
		return 0;
}


/* Mark this TSN as seen.  */
int sctp_tsnmap_mark(struct sctp_tsnmap *map, __u32 tsn,
		     struct sctp_transport *trans)
{
	u16 gap;

	if (TSN_lt(tsn, map->base_tsn))
		return 0;

	gap = tsn - map->base_tsn;

	if (gap >= map->len && !sctp_tsnmap_grow(map, gap + 1))
		return -ENOMEM;

	if (!sctp_tsnmap_has_gap(map) && gap == 0) {
		/* In this case the map has no gaps and the tsn we are
		 * recording is the next expected tsn.  We don't touch
		 * the map but simply bump the values.
		 */
		map->max_tsn_seen++;
		map->cumulative_tsn_ack_point++;
		if (trans)
			trans->sack_generation =
				trans->asoc->peer.sack_generation;
		map->base_tsn++;
	} else {
		/* Either we already have a gap, or about to record a gap, so
		 * have work to do.
		 *
		 * Bump the max.
		 */
		if (TSN_lt(map->max_tsn_seen, tsn))
			map->max_tsn_seen = tsn;

		/* Mark the TSN as received.  */
		set_bit(gap, map->tsn_map);

		/* Go fixup any internal TSN mapping variables including
		 * cumulative_tsn_ack_point.
		 */
		sctp_tsnmap_update(map);
	}

	return 0;
}


/* Initialize a Gap Ack Block iterator from memory being provided.  */
static void sctp_tsnmap_iter_init(const struct sctp_tsnmap *map,
				  struct sctp_tsnmap_iter *iter)
{
	/* Only start looking one past the Cumulative TSN Ack Point.  */
	iter->start = map->cumulative_tsn_ack_point + 1;
}

/* Get the next Gap Ack Blocks. Returns 0 if there was not another block
 * to get.
 */
static int sctp_tsnmap_next_gap_ack(const struct sctp_tsnmap *map,
				    struct sctp_tsnmap_iter *iter,
				    __u16 *start, __u16 *end)
{
	int ended = 0;
	__u16 start_ = 0, end_ = 0, offset;

	/* If there are no more gap acks possible, get out fast.  */
	if (TSN_lte(map->max_tsn_seen, iter->start))
		return 0;

	offset = iter->start - map->base_tsn;
	sctp_tsnmap_find_gap_ack(map->tsn_map, offset, map->len,
				 &start_, &end_);

	/* The Gap Ack Block happens to end at the end of the map. */
	if (start_ && !end_)
		end_ = map->len - 1;

	/* If we found a Gap Ack Block, return the start and end and
	 * bump the iterator forward.
	 */
	if (end_) {
		/* Fix up the start and end based on the
		 * Cumulative TSN Ack which is always 1 behind base.
		 */
		*start = start_ + 1;
		*end = end_ + 1;

		/* Move the iterator forward.  */
		iter->start = map->cumulative_tsn_ack_point + *end + 1;
		ended = 1;
	}

	return ended;
}

/* Mark this and any lower TSN as seen.  */
void sctp_tsnmap_skip(struct sctp_tsnmap *map, __u32 tsn)
{
	u32 gap;

	if (TSN_lt(tsn, map->base_tsn))
		return;
	if (!TSN_lt(tsn, map->base_tsn + SCTP_TSN_MAP_SIZE))
		return;

	/* Bump the max.  */
	if (TSN_lt(map->max_tsn_seen, tsn))
		map->max_tsn_seen = tsn;

	gap = tsn - map->base_tsn + 1;

	map->base_tsn += gap;
	map->cumulative_tsn_ack_point += gap;
	if (gap >= map->len) {
		/* If our gap is larger then the map size, just
		 * zero out the map.
		 */
		bitmap_zero(map->tsn_map, map->len);
	} else {
		/* If the gap is smaller than the map size,
		 * shift the map by 'gap' bits and update further.
		 */
		bitmap_shift_right(map->tsn_map, map->tsn_map, gap, map->len);
		sctp_tsnmap_update(map);
	}
}

/********************************************************************
 * 2nd Level Abstractions
 ********************************************************************/

/* This private helper function updates the tsnmap buffers and
 * the Cumulative TSN Ack Point.
 */
static void sctp_tsnmap_update(struct sctp_tsnmap *map)
{
	u16 len;
	unsigned long zero_bit;


	len = map->max_tsn_seen - map->cumulative_tsn_ack_point;
	zero_bit = find_first_zero_bit(map->tsn_map, len);
	if (!zero_bit)
		return;		/* The first 0-bit is bit 0.  nothing to do */

	map->base_tsn += zero_bit;
	map->cumulative_tsn_ack_point += zero_bit;

	bitmap_shift_right(map->tsn_map, map->tsn_map, zero_bit, map->len);
}

/* How many data chunks  are we missing from our peer?
 */
__u16 sctp_tsnmap_pending(struct sctp_tsnmap *map)
{
	__u32 cum_tsn = map->cumulative_tsn_ack_point;
	__u32 max_tsn = map->max_tsn_seen;
	__u32 base_tsn = map->base_tsn;
	__u16 pending_data;
	u32 gap;

	pending_data = max_tsn - cum_tsn;
	gap = max_tsn - base_tsn;

	if (gap == 0 || gap >= map->len)
		goto out;

	pending_data -= bitmap_weight(map->tsn_map, gap + 1);
out:
	return pending_data;
}

/* This is a private helper for finding Gap Ack Blocks.  It searches a
 * single array for the start and end of a Gap Ack Block.
 *
 * The flags "started" and "ended" tell is if we found the beginning
 * or (respectively) the end of a Gap Ack Block.
 */
static void sctp_tsnmap_find_gap_ack(unsigned long *map, __u16 off,
				     __u16 len, __u16 *start, __u16 *end)
{
	int i = off;

	/* Look through the entire array, but break out
	 * early if we have found the end of the Gap Ack Block.
	 */

	/* Also, stop looking past the maximum TSN seen. */

	/* Look for the start. */
	i = find_next_bit(map, len, off);
	if (i < len)
		*start = i;

	/* Look for the end.  */
	if (*start) {
		/* We have found the start, let's find the
		 * end.  If we find the end, break out.
		 */
		i = find_next_zero_bit(map, len, i);
		if (i < len)
			*end = i - 1;
	}
}

/* Renege that we have seen a TSN.  */
void sctp_tsnmap_renege(struct sctp_tsnmap *map, __u32 tsn)
{
	u32 gap;

	if (TSN_lt(tsn, map->base_tsn))
		return;
	/* Assert: TSN is in range.  */
	if (!TSN_lt(tsn, map->base_tsn + map->len))
		return;

	gap = tsn - map->base_tsn;

	/* Pretend we never saw the TSN.  */
	clear_bit(gap, map->tsn_map);
}

/* How many gap ack blocks do we have recorded? */
__u16 sctp_tsnmap_num_gabs(struct sctp_tsnmap *map,
			   struct sctp_gap_ack_block *gabs)
{
	struct sctp_tsnmap_iter iter;
	int ngaps = 0;

	/* Refresh the gap ack information. */
	if (sctp_tsnmap_has_gap(map)) {
		__u16 start = 0, end = 0;
		sctp_tsnmap_iter_init(map, &iter);
		while (sctp_tsnmap_next_gap_ack(map, &iter,
						&start,
						&end)) {

			gabs[ngaps].start = htons(start);
			gabs[ngaps].end = htons(end);
			ngaps++;
			if (ngaps >= SCTP_MAX_GABS)
				break;
		}
	}
	return ngaps;
}

static int sctp_tsnmap_grow(struct sctp_tsnmap *map, u16 size)
{
	unsigned long *new;
	unsigned long inc;
	u16  len;

	if (size > SCTP_TSN_MAP_SIZE)
		return 0;

	inc = ALIGN((size - map->len), BITS_PER_LONG) + SCTP_TSN_MAP_INCREMENT;
	len = min_t(u16, map->len + inc, SCTP_TSN_MAP_SIZE);

	new = kzalloc(len>>3, GFP_ATOMIC);
	if (!new)
		return 0;

	bitmap_copy(new, map->tsn_map,
		map->max_tsn_seen - map->cumulative_tsn_ack_point);
	kfree(map->tsn_map);
	map->tsn_map = new;
	map->len = len;

	return 1;
}
Commit	Line	Data
47505b8b	1	// SPDX-License-Identifier: GPL-2.0-or-later
60c778b2	2	/* SCTP kernel implementation
1da177e4 LT	3	* (C) Copyright IBM Corp. 2001, 2004
	4	* Copyright (c) 1999-2000 Cisco, Inc.
	5	* Copyright (c) 1999-2001 Motorola, Inc.
	6	* Copyright (c) 2001 Intel Corp.
	7	*
60c778b2	8	* This file is part of the SCTP kernel implementation
1da177e4 LT	9	*
	10	* These functions manipulate sctp tsn mapping array.
	11	*
1da177e4 LT	12	* Please send any bug reports or fixes you make to the
1da177e4 LT	13	* email address(es):
91705c61	14	* lksctp developers <linux-sctp@vger.kernel.org>
1da177e4	15	*
1da177e4 LT	16	* Written or modified by:
	17	* La Monte H.P. Yarroll <piggy@acm.org>
	18	* Jon Grimm <jgrimm@us.ibm.com>
	19	* Karl Knutson <karl@athena.chicago.il.us>
	20	* Sridhar Samudrala <sri@us.ibm.com>
1da177e4 LT	21	*/
1da177e4 LT	22
5a0e3ad6	23	#include <linux/slab.h>
1da177e4	24	#include <linux/types.h>
8e1ee18c	25	#include <linux/bitmap.h>
1da177e4 LT	26	#include <net/sctp/sctp.h>
	27	#include <net/sctp/sm.h>
	28
	29	static void sctp_tsnmap_update(struct sctp_tsnmap *map);
8e1ee18c VY	30	static void sctp_tsnmap_find_gap_ack(unsigned long *map, __u16 off,
8e1ee18c VY	31	__u16 len, __u16 start, __u16 end);
70fc69bc	32	static int sctp_tsnmap_grow(struct sctp_tsnmap *map, u16 size);
1da177e4 LT	33
	34	/* Initialize a block of memory as a tsnmap. */
	35	struct sctp_tsnmap sctp_tsnmap_init(struct sctp_tsnmap map, __u16 len,
8e1ee18c	36	__u32 initial_tsn, gfp_t gfp)
1da177e4	37	{
8e1ee18c VY	38	if (!map->tsn_map) {
	39	map->tsn_map = kzalloc(len>>3, gfp);
	40	if (map->tsn_map == NULL)
	41	return NULL;
	42
	43	map->len = len;
	44	} else {
	45	bitmap_zero(map->tsn_map, map->len);
	46	}
1da177e4 LT	47
	48	/* Keep track of TSNs represented by tsn_map. */
	49	map->base_tsn = initial_tsn;
1da177e4 LT	50	map->cumulative_tsn_ack_point = initial_tsn - 1;
1da177e4 LT	51	map->max_tsn_seen = map->cumulative_tsn_ack_point;
1da177e4 LT	52	map->num_dup_tsns = 0;
	53
	54	return map;
	55	}
	56
8e1ee18c VY	57	void sctp_tsnmap_free(struct sctp_tsnmap *map)
	58	{
	59	map->len = 0;
	60	kfree(map->tsn_map);
	61	}
	62
1da177e4 LT	63	/* Test the tracking state of this TSN.
	64	* Returns:
	65	* 0 if the TSN has not yet been seen
	66	* >0 if the TSN has been seen (duplicate)
	67	* <0 if the TSN is invalid (too large to track)
	68	*/
	69	int sctp_tsnmap_check(const struct sctp_tsnmap *map, __u32 tsn)
	70	{
8e1ee18c VY	71	u32 gap;
	72
	73	/* Check to see if this is an old TSN */
	74	if (TSN_lte(tsn, map->cumulative_tsn_ack_point))
	75	return 1;
	76
	77	/* Verify that we can hold this TSN and that it will not
d93ef301	78	* overflow our map
8e1ee18c VY	79	*/
	80	if (!TSN_lt(tsn, map->base_tsn + SCTP_TSN_MAP_SIZE))
	81	return -1;
1da177e4 LT	82
	83	/* Calculate the index into the mapping arrays. */
	84	gap = tsn - map->base_tsn;
	85
8e1ee18c VY	86	/* Check to see if TSN has already been recorded. */
	87	if (gap < map->len && test_bit(gap, map->tsn_map))
	88	return 1;
1da177e4	89	else
8e1ee18c	90	return 0;
1da177e4 LT	91	}
	92
	93
	94	/* Mark this TSN as seen. */
4244854d NH	95	int sctp_tsnmap_mark(struct sctp_tsnmap *map, __u32 tsn,
4244854d NH	96	struct sctp_transport *trans)
1da177e4	97	{
8e1ee18c	98	u16 gap;
1da177e4	99
1da177e4	100	if (TSN_lt(tsn, map->base_tsn))
8e1ee18c	101	return 0;
1da177e4	102
1da177e4 LT	103	gap = tsn - map->base_tsn;
1da177e4 LT	104
70fc69bc	105	if (gap >= map->len && !sctp_tsnmap_grow(map, gap + 1))
8e1ee18c	106	return -ENOMEM;
1da177e4	107
8e1ee18c VY	108	if (!sctp_tsnmap_has_gap(map) && gap == 0) {
	109	/* In this case the map has no gaps and the tsn we are
	110	* recording is the next expected tsn. We don't touch
	111	* the map but simply bump the values.
	112	*/
	113	map->max_tsn_seen++;
	114	map->cumulative_tsn_ack_point++;
4244854d NH	115	if (trans)
	116	trans->sack_generation =
	117	trans->asoc->peer.sack_generation;
8e1ee18c VY	118	map->base_tsn++;
	119	} else {
	120	/* Either we already have a gap, or about to record a gap, so
	121	* have work to do.
	122	*
	123	* Bump the max.
	124	*/
	125	if (TSN_lt(map->max_tsn_seen, tsn))
	126	map->max_tsn_seen = tsn;
	127
	128	/* Mark the TSN as received. */
	129	set_bit(gap, map->tsn_map);
	130
	131	/* Go fixup any internal TSN mapping variables including
	132	* cumulative_tsn_ack_point.
	133	*/
	134	sctp_tsnmap_update(map);
	135	}
	136
	137	return 0;
1da177e4 LT	138	}
	139
	140
	141	/* Initialize a Gap Ack Block iterator from memory being provided. */
dda91928 DB	142	static void sctp_tsnmap_iter_init(const struct sctp_tsnmap *map,
dda91928 DB	143	struct sctp_tsnmap_iter *iter)
1da177e4 LT	144	{
	145	/* Only start looking one past the Cumulative TSN Ack Point. */
	146	iter->start = map->cumulative_tsn_ack_point + 1;
	147	}
	148
	149	/* Get the next Gap Ack Blocks. Returns 0 if there was not another block
	150	* to get.
	151	*/
dda91928 DB	152	static int sctp_tsnmap_next_gap_ack(const struct sctp_tsnmap *map,
	153	struct sctp_tsnmap_iter *iter,
	154	__u16 start, __u16 end)
1da177e4	155	{
8e1ee18c VY	156	int ended = 0;
8e1ee18c VY	157	__u16 start_ = 0, end_ = 0, offset;
1da177e4 LT	158
	159	/* If there are no more gap acks possible, get out fast. */
	160	if (TSN_lte(map->max_tsn_seen, iter->start))
	161	return 0;
	162
8e1ee18c VY	163	offset = iter->start - map->base_tsn;
	164	sctp_tsnmap_find_gap_ack(map->tsn_map, offset, map->len,
	165	&start_, &end_);
1da177e4	166
8e1ee18c VY	167	/* The Gap Ack Block happens to end at the end of the map. */
	168	if (start_ && !end_)
	169	end_ = map->len - 1;
1da177e4 LT	170
	171	/* If we found a Gap Ack Block, return the start and end and
	172	* bump the iterator forward.
	173	*/
8e1ee18c	174	if (end_) {
1da177e4	175	/* Fix up the start and end based on the
8e1ee18c	176	* Cumulative TSN Ack which is always 1 behind base.
1da177e4	177	*/
8e1ee18c VY	178	*start = start_ + 1;
8e1ee18c VY	179	*end = end_ + 1;
1da177e4 LT	180
	181	/* Move the iterator forward. */
	182	iter->start = map->cumulative_tsn_ack_point + *end + 1;
8e1ee18c	183	ended = 1;
1da177e4 LT	184	}
	185
	186	return ended;
	187	}
	188
	189	/* Mark this and any lower TSN as seen. */
	190	void sctp_tsnmap_skip(struct sctp_tsnmap *map, __u32 tsn)
	191	{
8e1ee18c	192	u32 gap;
1da177e4	193
1da177e4 LT	194	if (TSN_lt(tsn, map->base_tsn))
1da177e4 LT	195	return;
8e1ee18c	196	if (!TSN_lt(tsn, map->base_tsn + SCTP_TSN_MAP_SIZE))
1da177e4 LT	197	return;
	198
	199	/* Bump the max. */
	200	if (TSN_lt(map->max_tsn_seen, tsn))
	201	map->max_tsn_seen = tsn;
	202
1da177e4 LT	203	gap = tsn - map->base_tsn + 1;
1da177e4 LT	204
8e1ee18c VY	205	map->base_tsn += gap;
	206	map->cumulative_tsn_ack_point += gap;
	207	if (gap >= map->len) {
	208	/* If our gap is larger then the map size, just
	209	* zero out the map.
	210	*/
	211	bitmap_zero(map->tsn_map, map->len);
	212	} else {
025dfdaf	213	/* If the gap is smaller than the map size,
8e1ee18c VY	214	* shift the map by 'gap' bits and update further.
	215	*/
	216	bitmap_shift_right(map->tsn_map, map->tsn_map, gap, map->len);
	217	sctp_tsnmap_update(map);
1da177e4	218	}
1da177e4 LT	219	}
	220
	221	/********************************************************************
	222	* 2nd Level Abstractions
	223	********************************************************************/
	224
	225	/* This private helper function updates the tsnmap buffers and
	226	* the Cumulative TSN Ack Point.
	227	*/
	228	static void sctp_tsnmap_update(struct sctp_tsnmap *map)
	229	{
8e1ee18c VY	230	u16 len;
	231	unsigned long zero_bit;
	232
	233
	234	len = map->max_tsn_seen - map->cumulative_tsn_ack_point;
	235	zero_bit = find_first_zero_bit(map->tsn_map, len);
	236	if (!zero_bit)
	237	return; /* The first 0-bit is bit 0. nothing to do */
	238
	239	map->base_tsn += zero_bit;
	240	map->cumulative_tsn_ack_point += zero_bit;
1da177e4	241
8e1ee18c	242	bitmap_shift_right(map->tsn_map, map->tsn_map, zero_bit, map->len);
1da177e4 LT	243	}
	244
	245	/* How many data chunks are we missing from our peer?
	246	*/
	247	__u16 sctp_tsnmap_pending(struct sctp_tsnmap *map)
	248	{
	249	__u32 cum_tsn = map->cumulative_tsn_ack_point;
	250	__u32 max_tsn = map->max_tsn_seen;
	251	__u32 base_tsn = map->base_tsn;
	252	__u16 pending_data;
fc184f08	253	u32 gap;
1da177e4 LT	254
	255	pending_data = max_tsn - cum_tsn;
	256	gap = max_tsn - base_tsn;
	257
8e1ee18c	258	if (gap == 0 \|\| gap >= map->len)
1da177e4 LT	259	goto out;
1da177e4 LT	260
fc184f08	261	pending_data -= bitmap_weight(map->tsn_map, gap + 1);
1da177e4 LT	262	out:
	263	return pending_data;
	264	}
	265
	266	/* This is a private helper for finding Gap Ack Blocks. It searches a
	267	* single array for the start and end of a Gap Ack Block.
	268	*
	269	* The flags "started" and "ended" tell is if we found the beginning
	270	* or (respectively) the end of a Gap Ack Block.
	271	*/
8e1ee18c VY	272	static void sctp_tsnmap_find_gap_ack(unsigned long *map, __u16 off,
8e1ee18c VY	273	__u16 len, __u16 start, __u16 end)
1da177e4 LT	274	{
	275	int i = off;
	276
	277	/* Look through the entire array, but break out
	278	* early if we have found the end of the Gap Ack Block.
	279	*/
	280
	281	/* Also, stop looking past the maximum TSN seen. */
	282
	283	/* Look for the start. */
8e1ee18c VY	284	i = find_next_bit(map, len, off);
	285	if (i < len)
	286	*start = i;
1da177e4 LT	287
1da177e4 LT	288	/* Look for the end. */
8e1ee18c	289	if (*start) {
1da177e4 LT	290	/* We have found the start, let's find the
	291	* end. If we find the end, break out.
	292	*/
8e1ee18c VY	293	i = find_next_zero_bit(map, len, i);
	294	if (i < len)
	295	*end = i - 1;
1da177e4 LT	296	}
	297	}
	298
	299	/* Renege that we have seen a TSN. */
	300	void sctp_tsnmap_renege(struct sctp_tsnmap *map, __u32 tsn)
	301	{
8e1ee18c	302	u32 gap;
1da177e4 LT	303
	304	if (TSN_lt(tsn, map->base_tsn))
	305	return;
8e1ee18c VY	306	/* Assert: TSN is in range. */
8e1ee18c VY	307	if (!TSN_lt(tsn, map->base_tsn + map->len))
1da177e4 LT	308	return;
1da177e4 LT	309
1da177e4 LT	310	gap = tsn - map->base_tsn;
	311
	312	/* Pretend we never saw the TSN. */
8e1ee18c	313	clear_bit(gap, map->tsn_map);
1da177e4 LT	314	}
	315
	316	/* How many gap ack blocks do we have recorded? */
02015180 VY	317	__u16 sctp_tsnmap_num_gabs(struct sctp_tsnmap *map,
02015180 VY	318	struct sctp_gap_ack_block *gabs)
1da177e4 LT	319	{
1da177e4 LT	320	struct sctp_tsnmap_iter iter;
02015180	321	int ngaps = 0;
1da177e4 LT	322
	323	/* Refresh the gap ack information. */
	324	if (sctp_tsnmap_has_gap(map)) {
59ed5aba	325	__u16 start = 0, end = 0;
1da177e4 LT	326	sctp_tsnmap_iter_init(map, &iter);
1da177e4 LT	327	while (sctp_tsnmap_next_gap_ack(map, &iter,
9f81bcd9 AV	328	&start,
9f81bcd9 AV	329	&end)) {
1da177e4	330
02015180 VY	331	gabs[ngaps].start = htons(start);
	332	gabs[ngaps].end = htons(end);
	333	ngaps++;
	334	if (ngaps >= SCTP_MAX_GABS)
1da177e4 LT	335	break;
	336	}
	337	}
02015180	338	return ngaps;
1da177e4	339	}
8e1ee18c	340
70fc69bc	341	static int sctp_tsnmap_grow(struct sctp_tsnmap *map, u16 size)
8e1ee18c VY	342	{
	343	unsigned long *new;
	344	unsigned long inc;
	345	u16 len;
	346
70fc69bc	347	if (size > SCTP_TSN_MAP_SIZE)
8e1ee18c VY	348	return 0;
8e1ee18c VY	349
70fc69bc	350	inc = ALIGN((size - map->len), BITS_PER_LONG) + SCTP_TSN_MAP_INCREMENT;
8e1ee18c VY	351	len = min_t(u16, map->len + inc, SCTP_TSN_MAP_SIZE);
	352
	353	new = kzalloc(len>>3, GFP_ATOMIC);
	354	if (!new)
	355	return 0;
	356
70fc69bc LR	357	bitmap_copy(new, map->tsn_map,
70fc69bc LR	358	map->max_tsn_seen - map->cumulative_tsn_ack_point);
8e1ee18c VY	359	kfree(map->tsn_map);
	360	map->tsn_map = new;
	361	map->len = len;
	362
	363	return 1;
	364	}