mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Jeff Kirsher](/assets/img/avatar_default.png)
Several files refer to an old address for the Free Software Foundation in the file header comment. Resolve by replacing the address with the URL <http://www.gnu.org/licenses/> so that we do not have to keep updating the header comments anytime the address changes. CC: Vlad Yasevich <vyasevich@gmail.com> CC: Neil Horman <nhorman@tuxdriver.com> Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com> Signed-off-by: David S. Miller <davem@davemloft.net>
379 lines
9.5 KiB
C
379 lines
9.5 KiB
C
/* 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.
|
|
*
|
|
* This SCTP implementation is free software;
|
|
* you can redistribute it and/or modify it under the terms of
|
|
* the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This SCTP implementation is distributed in the hope that it
|
|
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
* ************************
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNU CC; see the file COPYING. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*
|
|
* 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
|
|
* overlfow 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;
|
|
}
|