LXR linux/include/net/sctp/tsnmap.h

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/* SCTP kernel implementation
   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 *
   8 * This file is part of the SCTP kernel implementation
   9 *
  10 * These are the definitions needed for the tsnmap type.  The tsnmap is used
  11 * to track out of order TSNs received.
  12 *
  13 * Please send any bug reports or fixes you make to the
  14 * email address(es):
  15 *    lksctp developers <linux-sctp@vger.kernel.org>
  16 *
  17 * Written or modified by:
  18 *   Jon Grimm             <jgrimm@us.ibm.com>
  19 *   La Monte H.P. Yarroll <piggy@acm.org>
  20 *   Karl Knutson          <karl@athena.chicago.il.us>
  21 *   Sridhar Samudrala     <sri@us.ibm.com>
  22 */
  23#include <net/sctp/constants.h>
  24
  25#ifndef __sctp_tsnmap_h__
  26#define __sctp_tsnmap_h__
  27
  28/* RFC 2960 12.2 Parameters necessary per association (i.e. the TCB)
  29 * Mapping  An array of bits or bytes indicating which out of
  30 * Array    order TSN's have been received (relative to the
  31 *          Last Rcvd TSN). If no gaps exist, i.e. no out of
  32 *          order packets have been received, this array
  33 *          will be set to all zero. This structure may be
  34 *          in the form of a circular buffer or bit array.
  35 */
  36struct sctp_tsnmap {
  37        /* This array counts the number of chunks with each TSN.
  38         * It points at one of the two buffers with which we will
  39         * ping-pong between.
  40         */
  41        unsigned long *tsn_map;
  42
  43        /* This is the TSN at tsn_map[0].  */
  44        __u32 base_tsn;
  45
  46        /* Last Rcvd   : This is the last TSN received in
  47         * TSN         : sequence. This value is set initially by
  48         *             : taking the peer's Initial TSN, received in
  49         *             : the INIT or INIT ACK chunk, and subtracting
  50         *             : one from it.
  51         *
  52         * Throughout most of the specification this is called the
  53         * "Cumulative TSN ACK Point".  In this case, we
  54         * ignore the advice in 12.2 in favour of the term
  55         * used in the bulk of the text.
  56         */
  57        __u32 cumulative_tsn_ack_point;
  58
  59        /* This is the highest TSN we've marked.  */
  60        __u32 max_tsn_seen;
  61
  62        /* This is the minimum number of TSNs we can track.  This corresponds
  63         * to the size of tsn_map.   Note: the overflow_map allows us to
  64         * potentially track more than this quantity.
  65         */
  66        __u16 len;
  67
  68        /* Data chunks pending receipt. used by SCTP_STATUS sockopt */
  69        __u16 pending_data;
  70
  71        /* Record duplicate TSNs here.  We clear this after
  72         * every SACK.  Store up to SCTP_MAX_DUP_TSNS worth of
  73         * information.
  74         */
  75        __u16 num_dup_tsns;
  76        __be32 dup_tsns[SCTP_MAX_DUP_TSNS];
  77};
  78
  79struct sctp_tsnmap_iter {
  80        __u32 start;
  81};
  82
  83/* Initialize a block of memory as a tsnmap.  */
  84struct sctp_tsnmap *sctp_tsnmap_init(struct sctp_tsnmap *, __u16 len,
  85                                     __u32 initial_tsn, gfp_t gfp);
  86
  87void sctp_tsnmap_free(struct sctp_tsnmap *map);
  88
  89/* Test the tracking state of this TSN.
  90 * Returns:
  91 *   0 if the TSN has not yet been seen
  92 *  >0 if the TSN has been seen (duplicate)
  93 *  <0 if the TSN is invalid (too large to track)
  94 */
  95int sctp_tsnmap_check(const struct sctp_tsnmap *, __u32 tsn);
  96
  97/* Mark this TSN as seen.  */
  98int sctp_tsnmap_mark(struct sctp_tsnmap *, __u32 tsn,
  99                     struct sctp_transport *trans);
 100
 101/* Mark this TSN and all lower as seen. */
 102void sctp_tsnmap_skip(struct sctp_tsnmap *map, __u32 tsn);
 103
 104/* Retrieve the Cumulative TSN ACK Point.  */
 105static inline __u32 sctp_tsnmap_get_ctsn(const struct sctp_tsnmap *map)
 106{
 107        return map->cumulative_tsn_ack_point;
 108}
 109
 110/* Retrieve the highest TSN we've seen.  */
 111static inline __u32 sctp_tsnmap_get_max_tsn_seen(const struct sctp_tsnmap *map)
 112{
 113        return map->max_tsn_seen;
 114}
 115
 116/* How many duplicate TSNs are stored? */
 117static inline __u16 sctp_tsnmap_num_dups(struct sctp_tsnmap *map)
 118{
 119        return map->num_dup_tsns;
 120}
 121
 122/* Return pointer to duplicate tsn array as needed by SACK. */
 123static inline __be32 *sctp_tsnmap_get_dups(struct sctp_tsnmap *map)
 124{
 125        map->num_dup_tsns = 0;
 126        return map->dup_tsns;
 127}
 128
 129/* How many gap ack blocks do we have recorded? */
 130__u16 sctp_tsnmap_num_gabs(struct sctp_tsnmap *map,
 131                           struct sctp_gap_ack_block *gabs);
 132
 133/* Refresh the count on pending data. */
 134__u16 sctp_tsnmap_pending(struct sctp_tsnmap *map);
 135
 136/* Is there a gap in the TSN map?  */
 137static inline int sctp_tsnmap_has_gap(const struct sctp_tsnmap *map)
 138{
 139        return map->cumulative_tsn_ack_point != map->max_tsn_seen;
 140}
 141
 142/* Mark a duplicate TSN.  Note:  limit the storage of duplicate TSN
 143 * information.
 144 */
 145static inline void sctp_tsnmap_mark_dup(struct sctp_tsnmap *map, __u32 tsn)
 146{
 147        if (map->num_dup_tsns < SCTP_MAX_DUP_TSNS)
 148                map->dup_tsns[map->num_dup_tsns++] = htonl(tsn);
 149}
 150
 151/* Renege a TSN that was seen.  */
 152void sctp_tsnmap_renege(struct sctp_tsnmap *, __u32 tsn);
 153
 154/* Is there a gap in the TSN map? */
 155int sctp_tsnmap_has_gap(const struct sctp_tsnmap *);
 156
 157#endif /* __sctp_tsnmap_h__ */
 158