[linux-block.git] / net / rxrpc / proc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* /proc/net/ support for AF_RXRPC
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/module.h>
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include "ar-internal.h"

static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = {
	[RXRPC_CONN_UNUSED]			= "Unused  ",
	[RXRPC_CONN_CLIENT]			= "Client  ",
	[RXRPC_CONN_SERVICE_PREALLOC]		= "SvPrealc",
	[RXRPC_CONN_SERVICE_UNSECURED]		= "SvUnsec ",
	[RXRPC_CONN_SERVICE_CHALLENGING]	= "SvChall ",
	[RXRPC_CONN_SERVICE]			= "SvSecure",
	[RXRPC_CONN_REMOTELY_ABORTED]		= "RmtAbort",
	[RXRPC_CONN_LOCALLY_ABORTED]		= "LocAbort",
};

/*
 * generate a list of extant and dead calls in /proc/net/rxrpc_calls
 */
static void *rxrpc_call_seq_start(struct seq_file *seq, loff_t *_pos)
	__acquires(rcu)
	__acquires(rxnet->call_lock)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	rcu_read_lock();
	read_lock(&rxnet->call_lock);
	return seq_list_start_head(&rxnet->calls, *_pos);
}

static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	return seq_list_next(v, &rxnet->calls, pos);
}

static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
	__releases(rxnet->call_lock)
	__releases(rcu)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	read_unlock(&rxnet->call_lock);
	rcu_read_unlock();
}

static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
{
	struct rxrpc_local *local;
	struct rxrpc_sock *rx;
	struct rxrpc_peer *peer;
	struct rxrpc_call *call;
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	unsigned long timeout = 0;
	rxrpc_seq_t tx_hard_ack, rx_hard_ack;
	char lbuff[50], rbuff[50];

	if (v == &rxnet->calls) {
		seq_puts(seq,
			 "Proto Local                                          "
			 " Remote                                         "
			 " SvID ConnID   CallID   End Use State    Abort   "
			 " DebugId  TxSeq    TW RxSeq    RW RxSerial RxTimo\n");
		return 0;
	}

	call = list_entry(v, struct rxrpc_call, link);

	rx = rcu_dereference(call->socket);
	if (rx) {
		local = READ_ONCE(rx->local);
		if (local)
			sprintf(lbuff, "%pISpc", &local->srx.transport);
		else
			strcpy(lbuff, "no_local");
	} else {
		strcpy(lbuff, "no_socket");
	}

	peer = call->peer;
	if (peer)
		sprintf(rbuff, "%pISpc", &peer->srx.transport);
	else
		strcpy(rbuff, "no_connection");

	if (call->state != RXRPC_CALL_SERVER_PREALLOC) {
		timeout = READ_ONCE(call->expect_rx_by);
		timeout -= jiffies;
	}

	tx_hard_ack = READ_ONCE(call->tx_hard_ack);
	rx_hard_ack = READ_ONCE(call->rx_hard_ack);
	seq_printf(seq,
		   "UDP   %-47.47s %-47.47s %4x %08x %08x %s %3u"
		   " %-8.8s %08x %08x %08x %02x %08x %02x %08x %06lx\n",
		   lbuff,
		   rbuff,
		   call->service_id,
		   call->cid,
		   call->call_id,
		   rxrpc_is_service_call(call) ? "Svc" : "Clt",
		   atomic_read(&call->usage),
		   rxrpc_call_states[call->state],
		   call->abort_code,
		   call->debug_id,
		   tx_hard_ack, READ_ONCE(call->tx_top) - tx_hard_ack,
		   rx_hard_ack, READ_ONCE(call->rx_top) - rx_hard_ack,
		   call->rx_serial,
		   timeout);

	return 0;
}

const struct seq_operations rxrpc_call_seq_ops = {
	.start  = rxrpc_call_seq_start,
	.next   = rxrpc_call_seq_next,
	.stop   = rxrpc_call_seq_stop,
	.show   = rxrpc_call_seq_show,
};

/*
 * generate a list of extant virtual connections in /proc/net/rxrpc_conns
 */
static void *rxrpc_connection_seq_start(struct seq_file *seq, loff_t *_pos)
	__acquires(rxnet->conn_lock)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	read_lock(&rxnet->conn_lock);
	return seq_list_start_head(&rxnet->conn_proc_list, *_pos);
}

static void *rxrpc_connection_seq_next(struct seq_file *seq, void *v,
				       loff_t *pos)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	return seq_list_next(v, &rxnet->conn_proc_list, pos);
}

static void rxrpc_connection_seq_stop(struct seq_file *seq, void *v)
	__releases(rxnet->conn_lock)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));

	read_unlock(&rxnet->conn_lock);
}

static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)
{
	struct rxrpc_connection *conn;
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	char lbuff[50], rbuff[50];

	if (v == &rxnet->conn_proc_list) {
		seq_puts(seq,
			 "Proto Local                                          "
			 " Remote                                         "
			 " SvID ConnID   End Use State    Key     "
			 " Serial   ISerial  CallId0  CallId1  CallId2  CallId3\n"
			 );
		return 0;
	}

	conn = list_entry(v, struct rxrpc_connection, proc_link);
	if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) {
		strcpy(lbuff, "no_local");
		strcpy(rbuff, "no_connection");
		goto print;
	}

	sprintf(lbuff, "%pISpc", &conn->params.local->srx.transport);

	sprintf(rbuff, "%pISpc", &conn->params.peer->srx.transport);
print:
	seq_printf(seq,
		   "UDP   %-47.47s %-47.47s %4x %08x %s %3u"
		   " %s %08x %08x %08x %08x %08x %08x %08x\n",
		   lbuff,
		   rbuff,
		   conn->service_id,
		   conn->proto.cid,
		   rxrpc_conn_is_service(conn) ? "Svc" : "Clt",
		   atomic_read(&conn->usage),
		   rxrpc_conn_states[conn->state],
		   key_serial(conn->params.key),
		   atomic_read(&conn->serial),
		   conn->hi_serial,
		   conn->channels[0].call_id,
		   conn->channels[1].call_id,
		   conn->channels[2].call_id,
		   conn->channels[3].call_id);

	return 0;
}

const struct seq_operations rxrpc_connection_seq_ops = {
	.start  = rxrpc_connection_seq_start,
	.next   = rxrpc_connection_seq_next,
	.stop   = rxrpc_connection_seq_stop,
	.show   = rxrpc_connection_seq_show,
};

/*
 * generate a list of extant virtual peers in /proc/net/rxrpc/peers
 */
static int rxrpc_peer_seq_show(struct seq_file *seq, void *v)
{
	struct rxrpc_peer *peer;
	time64_t now;
	char lbuff[50], rbuff[50];

	if (v == SEQ_START_TOKEN) {
		seq_puts(seq,
			 "Proto Local                                          "
			 " Remote                                         "
			 " Use  CW   MTU LastUse      RTT      RTO\n"
			 );
		return 0;
	}

	peer = list_entry(v, struct rxrpc_peer, hash_link);

	sprintf(lbuff, "%pISpc", &peer->local->srx.transport);

	sprintf(rbuff, "%pISpc", &peer->srx.transport);

	now = ktime_get_seconds();
	seq_printf(seq,
		   "UDP   %-47.47s %-47.47s %3u"
		   " %3u %5u %6llus %8u %8u\n",
		   lbuff,
		   rbuff,
		   atomic_read(&peer->usage),
		   peer->cong_cwnd,
		   peer->mtu,
		   now - peer->last_tx_at,
		   peer->srtt_us >> 3,
		   jiffies_to_usecs(peer->rto_j));

	return 0;
}

static void *rxrpc_peer_seq_start(struct seq_file *seq, loff_t *_pos)
	__acquires(rcu)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	unsigned int bucket, n;
	unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
	void *p;

	rcu_read_lock();

	if (*_pos >= UINT_MAX)
		return NULL;

	n = *_pos & ((1U << shift) - 1);
	bucket = *_pos >> shift;
	for (;;) {
		if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
			*_pos = UINT_MAX;
			return NULL;
		}
		if (n == 0) {
			if (bucket == 0)
				return SEQ_START_TOKEN;
			*_pos += 1;
			n++;
		}

		p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
		if (p)
			return p;
		bucket++;
		n = 1;
		*_pos = (bucket << shift) | n;
	}
}

static void *rxrpc_peer_seq_next(struct seq_file *seq, void *v, loff_t *_pos)
{
	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	unsigned int bucket, n;
	unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
	void *p;

	if (*_pos >= UINT_MAX)
		return NULL;

	bucket = *_pos >> shift;

	p = seq_hlist_next_rcu(v, &rxnet->peer_hash[bucket], _pos);
	if (p)
		return p;

	for (;;) {
		bucket++;
		n = 1;
		*_pos = (bucket << shift) | n;

		if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
			*_pos = UINT_MAX;
			return NULL;
		}
		if (n == 0) {
			*_pos += 1;
			n++;
		}

		p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
		if (p)
			return p;
	}
}

static void rxrpc_peer_seq_stop(struct seq_file *seq, void *v)
	__releases(rcu)
{
	rcu_read_unlock();
}


const struct seq_operations rxrpc_peer_seq_ops = {
	.start  = rxrpc_peer_seq_start,
	.next   = rxrpc_peer_seq_next,
	.stop   = rxrpc_peer_seq_stop,
	.show   = rxrpc_peer_seq_show,
};
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
17926a79 DH	2	/* /proc/net/ support for AF_RXRPC
	3	*
	4	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
17926a79 DH	6	*/
	7
	8	#include <linux/module.h>
	9	#include <net/sock.h>
	10	#include <net/af_rxrpc.h>
	11	#include "ar-internal.h"
	12
bba304db DH	13	static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = {
	14	[RXRPC_CONN_UNUSED] = "Unused ",
	15	[RXRPC_CONN_CLIENT] = "Client ",
00e90712	16	[RXRPC_CONN_SERVICE_PREALLOC] = "SvPrealc",
bba304db DH	17	[RXRPC_CONN_SERVICE_UNSECURED] = "SvUnsec ",
	18	[RXRPC_CONN_SERVICE_CHALLENGING] = "SvChall ",
	19	[RXRPC_CONN_SERVICE] = "SvSecure",
	20	[RXRPC_CONN_REMOTELY_ABORTED] = "RmtAbort",
	21	[RXRPC_CONN_LOCALLY_ABORTED] = "LocAbort",
17926a79 DH	22	};
17926a79 DH	23
17926a79 DH	24	/*
	25	* generate a list of extant and dead calls in /proc/net/rxrpc_calls
	26	*/
	27	static void rxrpc_call_seq_start(struct seq_file seq, loff_t *_pos)
88f2a825 DH	28	__acquires(rcu)
88f2a825 DH	29	__acquires(rxnet->call_lock)
17926a79	30	{
2baec2c3 DH	31	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
2baec2c3 DH	32
8d94aa38	33	rcu_read_lock();
2baec2c3 DH	34	read_lock(&rxnet->call_lock);
2baec2c3 DH	35	return seq_list_start_head(&rxnet->calls, *_pos);
17926a79 DH	36	}
	37
	38	static void rxrpc_call_seq_next(struct seq_file seq, void v, loff_t pos)
	39	{
2baec2c3 DH	40	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	41
	42	return seq_list_next(v, &rxnet->calls, pos);
17926a79 DH	43	}
	44
	45	static void rxrpc_call_seq_stop(struct seq_file seq, void v)
88f2a825 DH	46	__releases(rxnet->call_lock)
88f2a825 DH	47	__releases(rcu)
17926a79	48	{
2baec2c3 DH	49	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	50
	51	read_unlock(&rxnet->call_lock);
8d94aa38	52	rcu_read_unlock();
17926a79 DH	53	}
	54
	55	static int rxrpc_call_seq_show(struct seq_file seq, void v)
	56	{
df5d8bf7 DH	57	struct rxrpc_local *local;
	58	struct rxrpc_sock *rx;
	59	struct rxrpc_peer *peer;
17926a79	60	struct rxrpc_call *call;
2baec2c3	61	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
770b26de	62	unsigned long timeout = 0;
3e018daf	63	rxrpc_seq_t tx_hard_ack, rx_hard_ack;
75b54cb5	64	char lbuff[50], rbuff[50];
17926a79	65
2baec2c3	66	if (v == &rxnet->calls) {
17926a79	67	seq_puts(seq,
75b54cb5 DH	68	"Proto Local "
75b54cb5 DH	69	" Remote "
17926a79	70	" SvID ConnID CallID End Use State Abort "
32f71aa4	71	" DebugId TxSeq TW RxSeq RW RxSerial RxTimo\n");
17926a79 DH	72	return 0;
	73	}
	74
	75	call = list_entry(v, struct rxrpc_call, link);
17926a79	76
8d94aa38	77	rx = rcu_dereference(call->socket);
df5d8bf7 DH	78	if (rx) {
	79	local = READ_ONCE(rx->local);
	80	if (local)
75b54cb5	81	sprintf(lbuff, "%pISpc", &local->srx.transport);
df5d8bf7 DH	82	else
	83	strcpy(lbuff, "no_local");
	84	} else {
	85	strcpy(lbuff, "no_socket");
	86	}
17926a79	87
df5d8bf7 DH	88	peer = call->peer;
df5d8bf7 DH	89	if (peer)
75b54cb5	90	sprintf(rbuff, "%pISpc", &peer->srx.transport);
f4e7da8c DH	91	else
f4e7da8c DH	92	strcpy(rbuff, "no_connection");
17926a79	93
887763bb DH	94	if (call->state != RXRPC_CALL_SERVER_PREALLOC) {
887763bb DH	95	timeout = READ_ONCE(call->expect_rx_by);
887763bb DH	96	timeout -= jiffies;
	97	}
	98
3e018daf DH	99	tx_hard_ack = READ_ONCE(call->tx_hard_ack);
3e018daf DH	100	rx_hard_ack = READ_ONCE(call->rx_hard_ack);
17926a79	101	seq_printf(seq,
75b54cb5	102	"UDP %-47.47s %-47.47s %4x %08x %08x %s %3u"
32f71aa4	103	" %-8.8s %08x %08x %08x %02x %08x %02x %08x %06lx\n",
17926a79 DH	104	lbuff,
17926a79 DH	105	rbuff,
f4e7da8c	106	call->service_id,
0d12f8a4 DH	107	call->cid,
0d12f8a4 DH	108	call->call_id,
dabe5a79	109	rxrpc_is_service_call(call) ? "Svc" : "Clt",
17926a79 DH	110	atomic_read(&call->usage),
17926a79 DH	111	rxrpc_call_states[call->state],
f5c17aae	112	call->abort_code,
32f71aa4	113	call->debug_id,
3e018daf	114	tx_hard_ack, READ_ONCE(call->tx_top) - tx_hard_ack,
887763bb	115	rx_hard_ack, READ_ONCE(call->rx_top) - rx_hard_ack,
6b97bd7a	116	call->rx_serial,
887763bb	117	timeout);
17926a79 DH	118
	119	return 0;
	120	}
	121
c3506372	122	const struct seq_operations rxrpc_call_seq_ops = {
17926a79 DH	123	.start = rxrpc_call_seq_start,
	124	.next = rxrpc_call_seq_next,
	125	.stop = rxrpc_call_seq_stop,
	126	.show = rxrpc_call_seq_show,
	127	};
	128
17926a79 DH	129	/*
	130	* generate a list of extant virtual connections in /proc/net/rxrpc_conns
	131	*/
	132	static void rxrpc_connection_seq_start(struct seq_file seq, loff_t *_pos)
88f2a825	133	__acquires(rxnet->conn_lock)
17926a79	134	{
2baec2c3 DH	135	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	136
	137	read_lock(&rxnet->conn_lock);
	138	return seq_list_start_head(&rxnet->conn_proc_list, *_pos);
17926a79 DH	139	}
	140
	141	static void rxrpc_connection_seq_next(struct seq_file seq, void *v,
	142	loff_t *pos)
	143	{
2baec2c3 DH	144	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	145
	146	return seq_list_next(v, &rxnet->conn_proc_list, pos);
17926a79 DH	147	}
	148
	149	static void rxrpc_connection_seq_stop(struct seq_file seq, void v)
88f2a825	150	__releases(rxnet->conn_lock)
17926a79	151	{
2baec2c3 DH	152	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	153
	154	read_unlock(&rxnet->conn_lock);
17926a79 DH	155	}
	156
	157	static int rxrpc_connection_seq_show(struct seq_file seq, void v)
	158	{
	159	struct rxrpc_connection *conn;
2baec2c3	160	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
75b54cb5	161	char lbuff[50], rbuff[50];
17926a79	162
2baec2c3	163	if (v == &rxnet->conn_proc_list) {
17926a79	164	seq_puts(seq,
75b54cb5 DH	165	"Proto Local "
75b54cb5 DH	166	" Remote "
a1399f8b	167	" SvID ConnID End Use State Key "
245500d8	168	" Serial ISerial CallId0 CallId1 CallId2 CallId3\n"
17926a79 DH	169	);
	170	return 0;
	171	}
	172
4d028b2c	173	conn = list_entry(v, struct rxrpc_connection, proc_link);
00e90712 DH	174	if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) {
	175	strcpy(lbuff, "no_local");
	176	strcpy(rbuff, "no_connection");
	177	goto print;
	178	}
17926a79	179
75b54cb5	180	sprintf(lbuff, "%pISpc", &conn->params.local->srx.transport);
17926a79	181
75b54cb5	182	sprintf(rbuff, "%pISpc", &conn->params.peer->srx.transport);
00e90712	183	print:
17926a79	184	seq_printf(seq,
75b54cb5	185	"UDP %-47.47s %-47.47s %4x %08x %s %3u"
6b97bd7a	186	" %s %08x %08x %08x %08x %08x %08x %08x\n",
17926a79 DH	187	lbuff,
17926a79 DH	188	rbuff,
68d6d1ae	189	conn->service_id,
19ffa01c	190	conn->proto.cid,
19ffa01c	191	rxrpc_conn_is_service(conn) ? "Svc" : "Clt",
17926a79 DH	192	atomic_read(&conn->usage),
17926a79 DH	193	rxrpc_conn_states[conn->state],
19ffa01c	194	key_serial(conn->params.key),
17926a79	195	atomic_read(&conn->serial),
6b97bd7a DH	196	conn->hi_serial,
	197	conn->channels[0].call_id,
	198	conn->channels[1].call_id,
	199	conn->channels[2].call_id,
	200	conn->channels[3].call_id);
17926a79 DH	201
	202	return 0;
	203	}
	204
c3506372	205	const struct seq_operations rxrpc_connection_seq_ops = {
17926a79 DH	206	.start = rxrpc_connection_seq_start,
	207	.next = rxrpc_connection_seq_next,
	208	.stop = rxrpc_connection_seq_stop,
	209	.show = rxrpc_connection_seq_show,
	210	};
bc0e7cf4 DH	211
	212	/*
	213	* generate a list of extant virtual peers in /proc/net/rxrpc/peers
	214	*/
	215	static int rxrpc_peer_seq_show(struct seq_file seq, void v)
	216	{
	217	struct rxrpc_peer *peer;
	218	time64_t now;
	219	char lbuff[50], rbuff[50];
	220
	221	if (v == SEQ_START_TOKEN) {
	222	seq_puts(seq,
	223	"Proto Local "
	224	" Remote "
c410bf01	225	" Use CW MTU LastUse RTT RTO\n"
bc0e7cf4 DH	226	);
	227	return 0;
	228	}
	229
	230	peer = list_entry(v, struct rxrpc_peer, hash_link);
	231
	232	sprintf(lbuff, "%pISpc", &peer->local->srx.transport);
	233
	234	sprintf(rbuff, "%pISpc", &peer->srx.transport);
	235
	236	now = ktime_get_seconds();
	237	seq_printf(seq,
	238	"UDP %-47.47s %-47.47s %3u"
c410bf01	239	" %3u %5u %6llus %8u %8u\n",
bc0e7cf4 DH	240	lbuff,
	241	rbuff,
	242	atomic_read(&peer->usage),
	243	peer->cong_cwnd,
	244	peer->mtu,
	245	now - peer->last_tx_at,
c410bf01 DH	246	peer->srtt_us >> 3,
c410bf01 DH	247	jiffies_to_usecs(peer->rto_j));
bc0e7cf4 DH	248
	249	return 0;
	250	}
	251
	252	static void rxrpc_peer_seq_start(struct seq_file seq, loff_t *_pos)
	253	__acquires(rcu)
	254	{
	255	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	256	unsigned int bucket, n;
	257	unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
	258	void *p;
	259
	260	rcu_read_lock();
	261
	262	if (*_pos >= UINT_MAX)
	263	return NULL;
	264
	265	n = *_pos & ((1U << shift) - 1);
	266	bucket = *_pos >> shift;
	267	for (;;) {
	268	if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
	269	*_pos = UINT_MAX;
	270	return NULL;
	271	}
	272	if (n == 0) {
	273	if (bucket == 0)
	274	return SEQ_START_TOKEN;
	275	*_pos += 1;
	276	n++;
	277	}
	278
	279	p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
	280	if (p)
	281	return p;
	282	bucket++;
	283	n = 1;
	284	*_pos = (bucket << shift) \| n;
	285	}
	286	}
	287
	288	static void rxrpc_peer_seq_next(struct seq_file seq, void v, loff_t _pos)
	289	{
	290	struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
	291	unsigned int bucket, n;
	292	unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
	293	void *p;
	294
	295	if (*_pos >= UINT_MAX)
	296	return NULL;
	297
	298	bucket = *_pos >> shift;
	299
	300	p = seq_hlist_next_rcu(v, &rxnet->peer_hash[bucket], _pos);
	301	if (p)
	302	return p;
	303
	304	for (;;) {
	305	bucket++;
	306	n = 1;
	307	*_pos = (bucket << shift) \| n;
	308
	309	if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
	310	*_pos = UINT_MAX;
	311	return NULL;
312	}
313	if (n == 0) {
314	*_pos += 1;
315	n++;
316	}
317
318	p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
319	if (p)
320	return p;
321	}
322	}
323
324	static void rxrpc_peer_seq_stop(struct seq_file seq, void v)
325	__releases(rcu)
326	{
327	rcu_read_unlock();
328	}
329
330
331	const struct seq_operations rxrpc_peer_seq_ops = {
332	.start = rxrpc_peer_seq_start,
333	.next = rxrpc_peer_seq_next,
334	.stop = rxrpc_peer_seq_stop,
335	.show = rxrpc_peer_seq_show,
336	};