1// SPDX-License-Identifier: GPL-2.0-or-later
 2/* Miscellaneous bits
 3 *
 4 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
 5 * Written by David Howells (dhowells@redhat.com)
 
 
 
 
 
 6 */
 7
 8#include <linux/kernel.h>
 9#include <net/sock.h>
10#include <net/af_rxrpc.h>
11#include "ar-internal.h"
12
13/*
14 * The maximum listening backlog queue size that may be set on a socket by
15 * listen().
16 */
17unsigned int rxrpc_max_backlog __read_mostly = 10;
18
19/*
 
 
 
 
 
 
20 * How long to wait before scheduling an ACK with subtype DELAY (in jiffies).
21 *
22 * We use this when we've received new data packets.  If those packets aren't
23 * all consumed within this time we will send a DELAY ACK if an ACK was not
24 * requested to let the sender know it doesn't need to resend.
25 */
26unsigned long rxrpc_soft_ack_delay = HZ;
27
28/*
29 * How long to wait before scheduling an ACK with subtype IDLE (in jiffies).
30 *
31 * We use this when we've consumed some previously soft-ACK'd packets when
32 * further packets aren't immediately received to decide when to send an IDLE
33 * ACK let the other end know that it can free up its Tx buffer space.
34 */
35unsigned long rxrpc_idle_ack_delay = HZ / 2;
36
37/*
38 * Receive window size in packets.  This indicates the maximum number of
39 * unconsumed received packets we're willing to retain in memory.  Once this
40 * limit is hit, we should generate an EXCEEDS_WINDOW ACK and discard further
41 * packets.
42 */
43unsigned int rxrpc_rx_window_size = 255;
 
 
 
44
45/*
46 * Maximum Rx MTU size.  This indicates to the sender the size of jumbo packet
47 * made by gluing normal packets together that we're willing to handle.
48 */
49unsigned int rxrpc_rx_mtu = 5692;
50
51/*
52 * The maximum number of fragments in a received jumbo packet that we tell the
53 * sender that we're willing to handle.
54 */
55unsigned int rxrpc_rx_jumbo_max = 4;

 
 1/* Miscellaneous bits
 2 *
 3 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
 4 * Written by David Howells (dhowells@redhat.com)
 5 *
 6 * This program is free software; you can redistribute it and/or
 7 * modify it under the terms of the GNU General Public Licence
 8 * as published by the Free Software Foundation; either version
 9 * 2 of the Licence, or (at your option) any later version.
10 */
11
12#include <linux/kernel.h>
13#include <net/sock.h>
14#include <net/af_rxrpc.h>
15#include "ar-internal.h"
16
17/*
18 * The maximum listening backlog queue size that may be set on a socket by
19 * listen().
20 */
21unsigned int rxrpc_max_backlog __read_mostly = 10;
22
23/*
24 * How long to wait before scheduling ACK generation after seeing a
25 * packet with RXRPC_REQUEST_ACK set (in jiffies).
26 */
27unsigned long rxrpc_requested_ack_delay = 1;
28
29/*
30 * How long to wait before scheduling an ACK with subtype DELAY (in jiffies).
31 *
32 * We use this when we've received new data packets.  If those packets aren't
33 * all consumed within this time we will send a DELAY ACK if an ACK was not
34 * requested to let the sender know it doesn't need to resend.
35 */
36unsigned long rxrpc_soft_ack_delay = HZ;
37
38/*
39 * How long to wait before scheduling an ACK with subtype IDLE (in jiffies).
40 *
41 * We use this when we've consumed some previously soft-ACK'd packets when
42 * further packets aren't immediately received to decide when to send an IDLE
43 * ACK let the other end know that it can free up its Tx buffer space.
44 */
45unsigned long rxrpc_idle_ack_delay = HZ / 2;
46
47/*
48 * Receive window size in packets.  This indicates the maximum number of
49 * unconsumed received packets we're willing to retain in memory.  Once this
50 * limit is hit, we should generate an EXCEEDS_WINDOW ACK and discard further
51 * packets.
52 */
53unsigned int rxrpc_rx_window_size = RXRPC_INIT_RX_WINDOW_SIZE;
54#if (RXRPC_RXTX_BUFF_SIZE - 1) < RXRPC_INIT_RX_WINDOW_SIZE
55#error Need to reduce RXRPC_INIT_RX_WINDOW_SIZE
56#endif
57
58/*
59 * Maximum Rx MTU size.  This indicates to the sender the size of jumbo packet
60 * made by gluing normal packets together that we're willing to handle.
61 */
62unsigned int rxrpc_rx_mtu = 5692;
63
64/*
65 * The maximum number of fragments in a received jumbo packet that we tell the
66 * sender that we're willing to handle.
67 */
68unsigned int rxrpc_rx_jumbo_max = 4;
69
70/*
71 * Time till packet resend (in milliseconds).
72 */
73unsigned long rxrpc_resend_timeout = 4 * HZ;
74
75const s8 rxrpc_ack_priority[] = {
76	[0]				= 0,
77	[RXRPC_ACK_DELAY]		= 1,
78	[RXRPC_ACK_REQUESTED]		= 2,
79	[RXRPC_ACK_IDLE]		= 3,
80	[RXRPC_ACK_DUPLICATE]		= 4,
81	[RXRPC_ACK_OUT_OF_SEQUENCE]	= 5,
82	[RXRPC_ACK_EXCEEDS_WINDOW]	= 6,
83	[RXRPC_ACK_NOSPACE]		= 7,
84	[RXRPC_ACK_PING_RESPONSE]	= 8,
85};