tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
RDS: loopback
A simple rds transport to handle loopback connections.
Signed-off-by: Andy Grover <andy.grover@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
authored by
Andy Grover
and committed by
David S. Miller
13796bf9
00e0f34c
+197
+188
net/rds/loop.c
+188
net/rds/loop.c
···
1
+
/*
2
+
* Copyright (c) 2006 Oracle. All rights reserved.
3
+
*
4
+
* This software is available to you under a choice of one of two
5
+
* licenses. You may choose to be licensed under the terms of the GNU
6
+
* General Public License (GPL) Version 2, available from the file
7
+
* COPYING in the main directory of this source tree, or the
8
+
* OpenIB.org BSD license below:
9
+
*
10
+
* Redistribution and use in source and binary forms, with or
11
+
* without modification, are permitted provided that the following
12
+
* conditions are met:
13
+
*
14
+
* - Redistributions of source code must retain the above
15
+
* copyright notice, this list of conditions and the following
16
+
* disclaimer.
17
+
*
18
+
* - Redistributions in binary form must reproduce the above
19
+
* copyright notice, this list of conditions and the following
20
+
* disclaimer in the documentation and/or other materials
21
+
* provided with the distribution.
22
+
*
23
+
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24
+
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25
+
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26
+
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27
+
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28
+
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29
+
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30
+
* SOFTWARE.
31
+
*
32
+
*/
33
+
#include <linux/kernel.h>
34
+
#include <linux/in.h>
35
+
36
+
#include "rds.h"
37
+
#include "loop.h"
38
+
39
+
static DEFINE_SPINLOCK(loop_conns_lock);
40
+
static LIST_HEAD(loop_conns);
41
+
42
+
/*
43
+
* This 'loopback' transport is a special case for flows that originate
44
+
* and terminate on the same machine.
45
+
*
46
+
* Connection build-up notices if the destination address is thought of
47
+
* as a local address by a transport. At that time it decides to use the
48
+
* loopback transport instead of the bound transport of the sending socket.
49
+
*
50
+
* The loopback transport's sending path just hands the sent rds_message
51
+
* straight to the receiving path via an embedded rds_incoming.
52
+
*/
53
+
54
+
/*
55
+
* Usually a message transits both the sender and receiver's conns as it
56
+
* flows to the receiver. In the loopback case, though, the receive path
57
+
* is handed the sending conn so the sense of the addresses is reversed.
58
+
*/
59
+
static int rds_loop_xmit(struct rds_connection *conn, struct rds_message *rm,
60
+
unsigned int hdr_off, unsigned int sg,
61
+
unsigned int off)
62
+
{
63
+
BUG_ON(hdr_off || sg || off);
64
+
65
+
rds_inc_init(&rm->m_inc, conn, conn->c_laddr);
66
+
rds_message_addref(rm); /* for the inc */
67
+
68
+
rds_recv_incoming(conn, conn->c_laddr, conn->c_faddr, &rm->m_inc,
69
+
GFP_KERNEL, KM_USER0);
70
+
71
+
rds_send_drop_acked(conn, be64_to_cpu(rm->m_inc.i_hdr.h_sequence),
72
+
NULL);
73
+
74
+
rds_inc_put(&rm->m_inc);
75
+
76
+
return sizeof(struct rds_header) + be32_to_cpu(rm->m_inc.i_hdr.h_len);
77
+
}
78
+
79
+
static int rds_loop_xmit_cong_map(struct rds_connection *conn,
80
+
struct rds_cong_map *map,
81
+
unsigned long offset)
82
+
{
83
+
unsigned long i;
84
+
85
+
BUG_ON(offset);
86
+
BUG_ON(map != conn->c_lcong);
87
+
88
+
for (i = 0; i < RDS_CONG_MAP_PAGES; i++) {
89
+
memcpy((void *)conn->c_fcong->m_page_addrs[i],
90
+
(void *)map->m_page_addrs[i], PAGE_SIZE);
91
+
}
92
+
93
+
rds_cong_map_updated(conn->c_fcong, ~(u64) 0);
94
+
95
+
return sizeof(struct rds_header) + RDS_CONG_MAP_BYTES;
96
+
}
97
+
98
+
/* we need to at least give the thread something to succeed */
99
+
static int rds_loop_recv(struct rds_connection *conn)
100
+
{
101
+
return 0;
102
+
}
103
+
104
+
struct rds_loop_connection {
105
+
struct list_head loop_node;
106
+
struct rds_connection *conn;
107
+
};
108
+
109
+
/*
110
+
* Even the loopback transport needs to keep track of its connections,
111
+
* so it can call rds_conn_destroy() on them on exit. N.B. there are
112
+
* 1+ loopback addresses (127.*.*.*) so it's not a bug to have
113
+
* multiple loopback conns allocated, although rather useless.
114
+
*/
115
+
static int rds_loop_conn_alloc(struct rds_connection *conn, gfp_t gfp)
116
+
{
117
+
struct rds_loop_connection *lc;
118
+
unsigned long flags;
119
+
120
+
lc = kzalloc(sizeof(struct rds_loop_connection), GFP_KERNEL);
121
+
if (lc == NULL)
122
+
return -ENOMEM;
123
+
124
+
INIT_LIST_HEAD(&lc->loop_node);
125
+
lc->conn = conn;
126
+
conn->c_transport_data = lc;
127
+
128
+
spin_lock_irqsave(&loop_conns_lock, flags);
129
+
list_add_tail(&lc->loop_node, &loop_conns);
130
+
spin_unlock_irqrestore(&loop_conns_lock, flags);
131
+
132
+
return 0;
133
+
}
134
+
135
+
static void rds_loop_conn_free(void *arg)
136
+
{
137
+
struct rds_loop_connection *lc = arg;
138
+
rdsdebug("lc %p\n", lc);
139
+
list_del(&lc->loop_node);
140
+
kfree(lc);
141
+
}
142
+
143
+
static int rds_loop_conn_connect(struct rds_connection *conn)
144
+
{
145
+
rds_connect_complete(conn);
146
+
return 0;
147
+
}
148
+
149
+
static void rds_loop_conn_shutdown(struct rds_connection *conn)
150
+
{
151
+
}
152
+
153
+
void rds_loop_exit(void)
154
+
{
155
+
struct rds_loop_connection *lc, *_lc;
156
+
LIST_HEAD(tmp_list);
157
+
158
+
/* avoid calling conn_destroy with irqs off */
159
+
spin_lock_irq(&loop_conns_lock);
160
+
list_splice(&loop_conns, &tmp_list);
161
+
INIT_LIST_HEAD(&loop_conns);
162
+
spin_unlock_irq(&loop_conns_lock);
163
+
164
+
list_for_each_entry_safe(lc, _lc, &tmp_list, loop_node) {
165
+
WARN_ON(lc->conn->c_passive);
166
+
rds_conn_destroy(lc->conn);
167
+
}
168
+
}
169
+
170
+
/*
171
+
* This is missing .xmit_* because loop doesn't go through generic
172
+
* rds_send_xmit() and doesn't call rds_recv_incoming(). .listen_stop and
173
+
* .laddr_check are missing because transport.c doesn't iterate over
174
+
* rds_loop_transport.
175
+
*/
176
+
struct rds_transport rds_loop_transport = {
177
+
.xmit = rds_loop_xmit,
178
+
.xmit_cong_map = rds_loop_xmit_cong_map,
179
+
.recv = rds_loop_recv,
180
+
.conn_alloc = rds_loop_conn_alloc,
181
+
.conn_free = rds_loop_conn_free,
182
+
.conn_connect = rds_loop_conn_connect,
183
+
.conn_shutdown = rds_loop_conn_shutdown,
184
+
.inc_copy_to_user = rds_message_inc_copy_to_user,
185
+
.inc_purge = rds_message_inc_purge,
186
+
.inc_free = rds_message_inc_free,
187
+
.t_name = "loopback",
188
+
};